// @generated message type with reflection information, may provide speed optimized methods
class LabelledPayload$Type extends MessageType<LabelledPayload> {
    constructor() {
        super("org.apache.beam.model.pipeline.v1.LabelledPayload", [
            { no: 1, name: "label", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
            { no: 2, name: "string_value", kind: "scalar", oneof: "value", T: 9 /*ScalarType.STRING*/ },
            { no: 3, name: "bool_value", kind: "scalar", oneof: "value", T: 8 /*ScalarType.BOOL*/ },
            { no: 4, name: "double_value", kind: "scalar", oneof: "value", T: 1 /*ScalarType.DOUBLE*/ },
            { no: 5, name: "int_value", kind: "scalar", oneof: "value", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 6, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
            { no: 7, name: "namespace", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
        ]);
    }
    create(value?: PartialMessage<LabelledPayload>): LabelledPayload {
        const message = { label: "", value: { oneofKind: undefined }, key: "", namespace: "" };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial<LabelledPayload>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: LabelledPayload): LabelledPayload {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string label */ 1:
                    message.label = reader.string();
                    break;
                case /* string string_value */ 2:
                    message.value = {
                        oneofKind: "stringValue",
                        stringValue: reader.string()
                    };
                    break;
                case /* bool bool_value */ 3:
                    message.value = {
                        oneofKind: "boolValue",
                        boolValue: reader.bool()
                    };
                    break;
                case /* double double_value */ 4:
                    message.value = {
                        oneofKind: "doubleValue",
                        doubleValue: reader.double()
                    };
                    break;
                case /* int64 int_value */ 5:
                    message.value = {
                        oneofKind: "intValue",
                        intValue: reader.int64().toBigInt()
                    };
                    break;
                case /* string key */ 6:
                    message.key = reader.string();
                    break;
                case /* string namespace */ 7:
                    message.namespace = reader.string();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: LabelledPayload, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* string label = 1; */
        if (message.label !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.label);
        /* string string_value = 2; */
        if (message.value.oneofKind === "stringValue")
            writer.tag(2, WireType.LengthDelimited).string(message.value.stringValue);
        /* bool bool_value = 3; */
        if (message.value.oneofKind === "boolValue")
            writer.tag(3, WireType.Varint).bool(message.value.boolValue);
        /* double double_value = 4; */
        if (message.value.oneofKind === "doubleValue")
            writer.tag(4, WireType.Bit64).double(message.value.doubleValue);
        /* int64 int_value = 5; */
        if (message.value.oneofKind === "intValue")
            writer.tag(5, WireType.Varint).int64(message.value.intValue);
        /* string key = 6; */
        if (message.key !== "")
            writer.tag(6, WireType.LengthDelimited).string(message.key);
        /* string namespace = 7; */
        if (message.namespace !== "")
            writer.tag(7, WireType.LengthDelimited).string(message.namespace);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}


// @generated message type with reflection information, may provide speed optimized methods
class DisplayData$Type extends MessageType<DisplayData> {
    constructor() {
        super("org.apache.beam.model.pipeline.v1.DisplayData", [
            { no: 1, name: "urn", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
            { no: 2, name: "payload", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
        ]);
    }
    create(value?: PartialMessage<DisplayData>): DisplayData {
        const message = { urn: "", payload: new Uint8Array(0) };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial<DisplayData>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DisplayData): DisplayData {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string urn */ 1:
                    message.urn = reader.string();
                    break;
                case /* bytes payload */ 2:
                    message.payload = reader.bytes();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: DisplayData, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* string urn = 1; */
        if (message.urn !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.urn);
        /* bytes payload = 2; */
        if (message.payload.length)
            writer.tag(2, WireType.LengthDelimited).bytes(message.payload);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}


// @generated message type with reflection information, may provide speed optimized methods
class ExecutableStagePayload_SideInputId$Type extends MessageType<ExecutableStagePayload_SideInputId> {
    constructor() {
        super("org.apache.beam.model.pipeline.v1.ExecutableStagePayload.SideInputId", [
            { no: 1, name: "transform_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
            { no: 2, name: "local_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
        ]);
    }
    create(value?: PartialMessage<ExecutableStagePayload_SideInputId>): ExecutableStagePayload_SideInputId {
        const message = { transformId: "", localName: "" };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial<ExecutableStagePayload_SideInputId>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutableStagePayload_SideInputId): ExecutableStagePayload_SideInputId {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string transform_id */ 1:
                    message.transformId = reader.string();
                    break;
                case /* string local_name */ 2:
                    message.localName = reader.string();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: ExecutableStagePayload_SideInputId, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* string transform_id = 1; */
        if (message.transformId !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.transformId);
        /* string local_name = 2; */
        if (message.localName !== "")
            writer.tag(2, WireType.LengthDelimited).string(message.localName);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}


// @generated message type with reflection information, may provide speed optimized methods
class ExecutableStagePayload_UserStateId$Type extends MessageType<ExecutableStagePayload_UserStateId> {
    constructor() {
        super("org.apache.beam.model.pipeline.v1.ExecutableStagePayload.UserStateId", [
            { no: 1, name: "transform_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
            { no: 2, name: "local_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
        ]);
    }
    create(value?: PartialMessage<ExecutableStagePayload_UserStateId>): ExecutableStagePayload_UserStateId {
        const message = { transformId: "", localName: "" };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial<ExecutableStagePayload_UserStateId>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutableStagePayload_UserStateId): ExecutableStagePayload_UserStateId {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string transform_id */ 1:
                    message.transformId = reader.string();
                    break;
                case /* string local_name */ 2:
                    message.localName = reader.string();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: ExecutableStagePayload_UserStateId, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* string transform_id = 1; */
        if (message.transformId !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.transformId);
        /* string local_name = 2; */
        if (message.localName !== "")
            writer.tag(2, WireType.LengthDelimited).string(message.localName);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}


// @generated message type with reflection information, may provide speed optimized methods
class ExecutableStagePayload_TimerId$Type extends MessageType<ExecutableStagePayload_TimerId> {
    constructor() {
        super("org.apache.beam.model.pipeline.v1.ExecutableStagePayload.TimerId", [
            { no: 1, name: "transform_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
            { no: 2, name: "local_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
        ]);
    }
    create(value?: PartialMessage<ExecutableStagePayload_TimerId>): ExecutableStagePayload_TimerId {
        const message = { transformId: "", localName: "" };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial<ExecutableStagePayload_TimerId>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutableStagePayload_TimerId): ExecutableStagePayload_TimerId {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string transform_id */ 1:
                    message.transformId = reader.string();
                    break;
                case /* string local_name */ 2:
                    message.localName = reader.string();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: ExecutableStagePayload_TimerId, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* string transform_id = 1; */
        if (message.transformId !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.transformId);
        /* string local_name = 2; */
        if (message.localName !== "")
            writer.tag(2, WireType.LengthDelimited).string(message.localName);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}


// @generated message type with reflection information, may provide speed optimized methods
class ExecutableStagePayload_TimerFamilyId$Type extends MessageType<ExecutableStagePayload_TimerFamilyId> {
    constructor() {
        super("org.apache.beam.model.pipeline.v1.ExecutableStagePayload.TimerFamilyId", [
            { no: 1, name: "transform_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
            { no: 2, name: "local_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
        ]);
    }
    create(value?: PartialMessage<ExecutableStagePayload_TimerFamilyId>): ExecutableStagePayload_TimerFamilyId {
        const message = { transformId: "", localName: "" };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial<ExecutableStagePayload_TimerFamilyId>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutableStagePayload_TimerFamilyId): ExecutableStagePayload_TimerFamilyId {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string transform_id */ 1:
                    message.transformId = reader.string();
                    break;
                case /* string local_name */ 2:
                    message.localName = reader.string();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: ExecutableStagePayload_TimerFamilyId, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* string transform_id = 1; */
        if (message.transformId !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.transformId);
        /* string local_name = 2; */
        if (message.localName !== "")
            writer.tag(2, WireType.LengthDelimited).string(message.localName);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}


// @generated message type with reflection information, may provide speed optimized methods
class ExecutableStagePayload_WireCoderSetting$Type extends MessageType<ExecutableStagePayload_WireCoderSetting> {
    constructor() {
        super("org.apache.beam.model.pipeline.v1.ExecutableStagePayload.WireCoderSetting", [
            { no: 1, name: "urn", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
            { no: 2, name: "payload", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
            { no: 3, name: "input_or_output_id", kind: "scalar", oneof: "target", T: 9 /*ScalarType.STRING*/ },
            { no: 4, name: "timer", kind: "message", oneof: "target", T: () => ExecutableStagePayload_TimerId }
        ]);
    }
    create(value?: PartialMessage<ExecutableStagePayload_WireCoderSetting>): ExecutableStagePayload_WireCoderSetting {
        const message = { urn: "", payload: new Uint8Array(0), target: { oneofKind: undefined } };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial<ExecutableStagePayload_WireCoderSetting>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutableStagePayload_WireCoderSetting): ExecutableStagePayload_WireCoderSetting {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string urn */ 1:
                    message.urn = reader.string();
                    break;
                case /* bytes payload */ 2:
                    message.payload = reader.bytes();
                    break;
                case /* string input_or_output_id */ 3:
                    message.target = {
                        oneofKind: "inputOrOutputId",
                        inputOrOutputId: reader.string()
                    };
                    break;
                case /* org.apache.beam.model.pipeline.v1.ExecutableStagePayload.TimerId timer */ 4:
                    message.target = {
                        oneofKind: "timer",
                        timer: ExecutableStagePayload_TimerId.internalBinaryRead(reader, reader.uint32(), options, (message.target as any).timer)
                    };
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: ExecutableStagePayload_WireCoderSetting, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* string urn = 1; */
        if (message.urn !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.urn);
        /* bytes payload = 2; */
        if (message.payload.length)
            writer.tag(2, WireType.LengthDelimited).bytes(message.payload);
        /* string input_or_output_id = 3; */
        if (message.target.oneofKind === "inputOrOutputId")
            writer.tag(3, WireType.LengthDelimited).string(message.target.inputOrOutputId);
        /* org.apache.beam.model.pipeline.v1.ExecutableStagePayload.TimerId timer = 4; */
        if (message.target.oneofKind === "timer")
            ExecutableStagePayload_TimerId.internalBinaryWrite(message.target.timer, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}


// @generated message type with reflection information, may provide speed optimized methods
class StandardResourceHints$Type extends MessageType<StandardResourceHints> {
    constructor() {
        super("org.apache.beam.model.pipeline.v1.StandardResourceHints", []);
    }
    create(value?: PartialMessage<StandardResourceHints>): StandardResourceHints {
        const message = {};
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial<StandardResourceHints>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StandardResourceHints): StandardResourceHints {
        return target ?? this.create();
    }
    internalBinaryWrite(message: StandardResourceHints, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.BeamConstants
 */
export interface BeamConstants {
}


/**
 * A set of mappings from id to message. This is included as an optional field
 * on any proto message that may contain references needing resolution.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.Components
 */
export interface Components {
    /**
     * (Required) A map from pipeline-scoped id to PTransform.
     *
     * Keys of the transforms map may be used by runners to identify pipeline
     * steps. Hence it's recommended to use strings that are not too long that
     * match regex '[A-Za-z0-9-_]+'.
     *
     * @generated from protobuf field: map<string, org.apache.beam.model.pipeline.v1.PTransform> transforms = 1;
     */
    transforms: {
        [key: string]: PTransform;
    };
    /**
     * (Required) A map from pipeline-scoped id to PCollection.
     *
     * @generated from protobuf field: map<string, org.apache.beam.model.pipeline.v1.PCollection> pcollections = 2;
     */
    pcollections: {
        [key: string]: PCollection;
    };
    /**
     * (Required) A map from pipeline-scoped id to WindowingStrategy.
     *
     * @generated from protobuf field: map<string, org.apache.beam.model.pipeline.v1.WindowingStrategy> windowing_strategies = 3;
     */
    windowingStrategies: {
        [key: string]: WindowingStrategy;
    };
    /**
     * (Required) A map from pipeline-scoped id to Coder.
     *
     * @generated from protobuf field: map<string, org.apache.beam.model.pipeline.v1.Coder> coders = 4;
     */
    coders: {
        [key: string]: Coder;
    };
    /**
     * (Required) A map from pipeline-scoped id to Environment.
     *
     * @generated from protobuf field: map<string, org.apache.beam.model.pipeline.v1.Environment> environments = 5;
     */
    environments: {
        [key: string]: Environment;
    };
}


/**
 * A Pipeline is a hierarchical graph of PTransforms, linked
 * by PCollections. A typical graph may look like:
 *
 *   Impulse -> PCollection -> ParDo -> PCollection -> GroupByKey -> ...
 *                                   \> PCollection -> ParDo      -> ...
 *                                                  \> ParDo      -> ...
 *   Impulse -> PCollection -> ParDo -> PCollection -> ...
 *
 * This is represented by a number of by-reference maps to transforms,
 * PCollections, SDK environments, coders, etc., for
 * supporting compact reuse and arbitrary graph structure.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.Pipeline
 */
export interface Pipeline {
    /**
     * (Required) The coders, UDFs, graph nodes, etc, that make up
     * this pipeline.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Components components = 1;
     */
    components?: Components;
    /**
     * (Required) The ids of all PTransforms that are not contained within another
     * PTransform. These must be in shallow topological order, so that traversing
     * them recursively in this order yields a recursively topological traversal.
     *
     * @generated from protobuf field: repeated string root_transform_ids = 2;
     */
    rootTransformIds: string[];
    /**
     * (Optional) Static display data for the pipeline. If there is none,
     * it may be omitted.
     *
     * @generated from protobuf field: repeated org.apache.beam.model.pipeline.v1.DisplayData display_data = 3;
     */
    displayData: DisplayData[];
    /**
     * (Optional) A set of requirements that the runner MUST understand and be
     * able to faithfully provide in order to execute this pipeline. These
     * may indicate that a runner must inspect new fields on a component or
     * provide additional guarantees when processing specific transforms.
     * A runner should reject any pipelines with unknown requirements.
     *
     * @generated from protobuf field: repeated string requirements = 4;
     */
    requirements: string[];
}


/**
 * Transforms are the operations in your pipeline, and provide a generic
 * processing framework. You provide processing logic in the form of a function
 * object (colloquially referred to as “user code”), and your user code is
 * applied to each element of an input PCollection (or more than one
 * PCollection). Depending on the pipeline runner and back-end that you choose,
 * many different workers across a cluster may execute instances of your user
 * code in parallel. The user code running on each worker generates the output
 * elements that are ultimately added to the final output PCollection that the
 * transform produces.
 *
 * The Beam SDKs contain a number of different transforms that you can apply to
 * your pipeline’s PCollections. These include general-purpose core transforms,
 * such as ParDo or Combine. There are also pre-written composite transforms
 * included in the SDKs, which combine one or more of the core transforms in a
 * useful processing pattern, such as counting or combining elements in a
 * collection. You can also define your own more complex composite transforms to
 * fit your pipeline’s exact use case.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.PTransform
 */
export interface PTransform {
    /**
     * (Required) A unique name for the application node.
     *
     * Ideally, this should be stable over multiple evolutions of a pipeline
     * for the purposes of logging and associating pipeline state with a node,
     * etc.
     *
     * If it is not stable, then the runner decides what will happen. But, most
     * importantly, it must always be here and be unique, even if it is
     * autogenerated.
     *
     * @generated from protobuf field: string unique_name = 5;
     */
    uniqueName: string;
    /**
     * (Optional) A URN and payload that, together, fully defined the semantics
     * of this transform.
     *
     * If absent, this must be an "anonymous" composite transform.
     *
     * For primitive transform in the Runner API, this is required, and the
     * payloads are well-defined messages. When the URN indicates ParDo it
     * is a ParDoPayload, and so on. For some special composite transforms,
     * the payload is also officially defined. See StandardPTransforms for
     * details.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.FunctionSpec spec = 1;
     */
    spec?: FunctionSpec;
    /**
     * (Optional) A list of the ids of transforms that it contains.
     *
     * Primitive transforms (see StandardPTransforms.Primitives) are not allowed
     * to specify subtransforms.
     *
     * Note that a composite transform may have zero subtransforms as long as it
     * only outputs PCollections that are in its inputs.
     *
     * @generated from protobuf field: repeated string subtransforms = 2;
     */
    subtransforms: string[];
    /**
     * (Required) A map from local names of inputs (unique only with this map, and
     * likely embedded in the transform payload and serialized user code) to
     * PCollection ids.
     *
     * The payload for this transform may clarify the relationship of these
     * inputs. For example:
     *
     *  - for a Flatten transform they are merged
     *  - for a ParDo transform, some may be side inputs
     *
     * All inputs are recorded here so that the topological ordering of
     * the graph is consistent whether or not the payload is understood.
     *
     * @generated from protobuf field: map<string, string> inputs = 3;
     */
    inputs: {
        [key: string]: string;
    };
    /**
     * (Required) A map from local names of outputs (unique only within this map,
     * and likely embedded in the transform payload and serialized user code)
     * to PCollection ids.
     *
     * The URN or payload for this transform node may clarify the type and
     * relationship of these outputs. For example:
     *
     *  - for a ParDo transform, these are tags on PCollections, which will be
     *    embedded in the DoFn.
     *
     * @generated from protobuf field: map<string, string> outputs = 4;
     */
    outputs: {
        [key: string]: string;
    };
    /**
     * (Optional) Static display data for this PTransform application. If
     * there is none, it may be omitted.
     *
     * @generated from protobuf field: repeated org.apache.beam.model.pipeline.v1.DisplayData display_data = 6;
     */
    displayData: DisplayData[];
    /**
     * Environment where the current PTransform should be executed in.
     *
     * Transforms that are required to be implemented by a runner must omit this.
     * All other transforms are required to specify this.
     *
     * @generated from protobuf field: string environment_id = 7;
     */
    environmentId: string;
    /**
     * (Optional) A map from URNs designating a type of annotation, to the
     * annotation in binary format. For example, an annotation could indicate
     * that this PTransform has specific privacy properties.
     *
     * A runner MAY ignore types of annotations it doesn't understand. Therefore
     * annotations MUST NOT be used for metadata that can affect correct
     * execution of the transform.
     *
     * @generated from protobuf field: map<string, bytes> annotations = 8;
     */
    annotations: {
        [key: string]: Uint8Array;
    };
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.StandardPTransforms
 */
export interface StandardPTransforms {
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.StandardSideInputTypes
 */
export interface StandardSideInputTypes {
}


/**
 * A PCollection!
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.PCollection
 */
export interface PCollection {
    /**
     * (Required) A unique name for the PCollection.
     *
     * Ideally, this should be stable over multiple evolutions of a pipeline
     * for the purposes of logging and associating pipeline state with a node,
     * etc.
     *
     * If it is not stable, then the runner decides what will happen. But, most
     * importantly, it must always be here, even if it is autogenerated.
     *
     * @generated from protobuf field: string unique_name = 1;
     */
    uniqueName: string;
    /**
     * (Required) The id of the Coder for this PCollection.
     *
     * @generated from protobuf field: string coder_id = 2;
     */
    coderId: string;
    /**
     * (Required) Whether this PCollection is bounded or unbounded
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.IsBounded.Enum is_bounded = 3;
     */
    isBounded: IsBounded_Enum;
    /**
     * (Required) The id of the windowing strategy for this PCollection.
     *
     * @generated from protobuf field: string windowing_strategy_id = 4;
     */
    windowingStrategyId: string;
    /**
     * (Optional) Static display data for the PCollection. If there is none,
     * it may be omitted.
     *
     * @generated from protobuf field: repeated org.apache.beam.model.pipeline.v1.DisplayData display_data = 5;
     */
    displayData: DisplayData[];
}


/**
 * The payload for the primitive ParDo transform.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.ParDoPayload
 */
export interface ParDoPayload {
    /**
     * (Required) The FunctionSpec of the DoFn.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.FunctionSpec do_fn = 1;
     */
    doFn?: FunctionSpec;
    /**
     * (Optional) A mapping of local input names to side inputs, describing
     * the expected access pattern.
     *
     * @generated from protobuf field: map<string, org.apache.beam.model.pipeline.v1.SideInput> side_inputs = 3;
     */
    sideInputs: {
        [key: string]: SideInput;
    };
    /**
     * (Optional) A mapping of local state names to state specifications.
     * If this is set, the stateful processing requirement should also
     * be placed in the pipeline requirements.
     *
     * @generated from protobuf field: map<string, org.apache.beam.model.pipeline.v1.StateSpec> state_specs = 4;
     */
    stateSpecs: {
        [key: string]: StateSpec;
    };
    /**
     * (Optional) A mapping of local timer family names to timer family
     * specifications. If this is set, the stateful processing requirement should
     * also be placed in the pipeline requirements.
     *
     * @generated from protobuf field: map<string, org.apache.beam.model.pipeline.v1.TimerFamilySpec> timer_family_specs = 9;
     */
    timerFamilySpecs: {
        [key: string]: TimerFamilySpec;
    };
    /**
     * (Optional) Only set when this ParDo contains a splittable DoFn.
     * If this is set, the corresponding standard requirement should also
     * be placed in the pipeline requirements.
     *
     * @generated from protobuf field: string restriction_coder_id = 7;
     */
    restrictionCoderId: string;
    /**
     * (Optional) Only set when this ParDo can request bundle finalization.
     * If this is set, the corresponding standard requirement should also
     * be placed in the pipeline requirements.
     *
     * @generated from protobuf field: bool requests_finalization = 8;
     */
    requestsFinalization: boolean;
    /**
     * Whether this stage requires time sorted input.
     * If this is set, the corresponding standard requirement should also
     * be placed in the pipeline requirements.
     *
     * @generated from protobuf field: bool requires_time_sorted_input = 10;
     */
    requiresTimeSortedInput: boolean;
    /**
     * Whether this stage requires stable input.
     * If this is set, the corresponding standard requirement should also
     * be placed in the pipeline requirements.
     *
     * @generated from protobuf field: bool requires_stable_input = 11;
     */
    requiresStableInput: boolean;
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.StateSpec
 */
export interface StateSpec {
    /**
     * @generated from protobuf oneof: spec
     */
    spec: {
        oneofKind: "readModifyWriteSpec";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.ReadModifyWriteStateSpec read_modify_write_spec = 1;
         */
        readModifyWriteSpec: ReadModifyWriteStateSpec;
    } | {
        oneofKind: "bagSpec";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.BagStateSpec bag_spec = 2;
         */
        bagSpec: BagStateSpec;
    } | {
        oneofKind: "combiningSpec";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.CombiningStateSpec combining_spec = 3;
         */
        combiningSpec: CombiningStateSpec;
    } | {
        oneofKind: "mapSpec";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.MapStateSpec map_spec = 4;
         */
        mapSpec: MapStateSpec;
    } | {
        oneofKind: "setSpec";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.SetStateSpec set_spec = 5;
         */
        setSpec: SetStateSpec;
    } | {
        oneofKind: "orderedListSpec";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.OrderedListStateSpec ordered_list_spec = 6;
         */
        orderedListSpec: OrderedListStateSpec;
    } | {
        oneofKind: undefined;
    };
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.ReadModifyWriteStateSpec
 */
export interface ReadModifyWriteStateSpec {
    /**
     * @generated from protobuf field: string coder_id = 1;
     */
    coderId: string;
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.BagStateSpec
 */
export interface BagStateSpec {
    /**
     * @generated from protobuf field: string element_coder_id = 1;
     */
    elementCoderId: string;
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.OrderedListStateSpec
 */
export interface OrderedListStateSpec {
    /**
     * @generated from protobuf field: string element_coder_id = 1;
     */
    elementCoderId: string;
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.CombiningStateSpec
 */
export interface CombiningStateSpec {
    /**
     * @generated from protobuf field: string accumulator_coder_id = 1;
     */
    accumulatorCoderId: string;
    /**
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.FunctionSpec combine_fn = 2;
     */
    combineFn?: FunctionSpec;
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.MapStateSpec
 */
export interface MapStateSpec {
    /**
     * @generated from protobuf field: string key_coder_id = 1;
     */
    keyCoderId: string;
    /**
     * @generated from protobuf field: string value_coder_id = 2;
     */
    valueCoderId: string;
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.SetStateSpec
 */
export interface SetStateSpec {
    /**
     * @generated from protobuf field: string element_coder_id = 1;
     */
    elementCoderId: string;
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.TimerFamilySpec
 */
export interface TimerFamilySpec {
    /**
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.TimeDomain.Enum time_domain = 1;
     */
    timeDomain: TimeDomain_Enum;
    /**
     * @generated from protobuf field: string timer_family_coder_id = 2;
     */
    timerFamilyCoderId: string;
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.IsBounded
 */
export interface IsBounded {
}


/**
 * The payload for the primitive Read transform.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.ReadPayload
 */
export interface ReadPayload {
    /**
     * (Required) The FunctionSpec of the source for this Read.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.FunctionSpec source = 1;
     */
    source?: FunctionSpec;
    /**
     * (Required) Whether the source is bounded or unbounded
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.IsBounded.Enum is_bounded = 2;
     */
    isBounded: IsBounded_Enum;
}


/**
 * The payload for the WindowInto transform.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.WindowIntoPayload
 */
export interface WindowIntoPayload {
    /**
     * (Required) The FunctionSpec of the WindowFn.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.FunctionSpec window_fn = 1;
     */
    windowFn?: FunctionSpec;
}


/**
 * The payload for the special-but-not-primitive Combine transform.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.CombinePayload
 */
export interface CombinePayload {
    /**
     * (Required) The FunctionSpec of the CombineFn.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.FunctionSpec combine_fn = 1;
     */
    combineFn?: FunctionSpec;
    /**
     * (Required) A reference to the Coder to use for accumulators of the CombineFn
     *
     * @generated from protobuf field: string accumulator_coder_id = 2;
     */
    accumulatorCoderId: string;
}


/**
 * The payload for the test-only primitive TestStream
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.TestStreamPayload
 */
export interface TestStreamPayload {
    /**
     * (Required) the coder for elements in the TestStream events
     *
     * @generated from protobuf field: string coder_id = 1;
     */
    coderId: string;
    /**
     * (Optional) If specified, the TestStream will replay these events.
     *
     * @generated from protobuf field: repeated org.apache.beam.model.pipeline.v1.TestStreamPayload.Event events = 2;
     */
    events: TestStreamPayload_Event[];
    /**
     * (Optional) If specified, points to a TestStreamService to be
     * used to retrieve events.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.ApiServiceDescriptor endpoint = 3;
     */
    endpoint?: ApiServiceDescriptor;
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.TestStreamPayload.Event
 */
export interface TestStreamPayload_Event {
    /**
     * @generated from protobuf oneof: event
     */
    event: {
        oneofKind: "watermarkEvent";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.TestStreamPayload.Event.AdvanceWatermark watermark_event = 1;
         */
        watermarkEvent: TestStreamPayload_Event_AdvanceWatermark;
    } | {
        oneofKind: "processingTimeEvent";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.TestStreamPayload.Event.AdvanceProcessingTime processing_time_event = 2;
         */
        processingTimeEvent: TestStreamPayload_Event_AdvanceProcessingTime;
    } | {
        oneofKind: "elementEvent";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.TestStreamPayload.Event.AddElements element_event = 3;
         */
        elementEvent: TestStreamPayload_Event_AddElements;
    } | {
        oneofKind: undefined;
    };
}


/**
 * Advances the watermark to the specified timestamp.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.TestStreamPayload.Event.AdvanceWatermark
 */
export interface TestStreamPayload_Event_AdvanceWatermark {
    /**
     * (Required) The watermark in millisecond to advance to.
     *
     * @generated from protobuf field: int64 new_watermark = 1;
     */
    newWatermark: bigint;
    /**
     * (Optional) The output watermark tag for a PCollection. If unspecified
     * or with an empty string, this will default to the Main PCollection
     * Output
     *
     * @generated from protobuf field: string tag = 2;
     */
    tag: string;
}


/**
 * Advances the processing time clock by the specified amount.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.TestStreamPayload.Event.AdvanceProcessingTime
 */
export interface TestStreamPayload_Event_AdvanceProcessingTime {
    /**
     * (Required) The duration in millisecond to advance by.
     *
     * @generated from protobuf field: int64 advance_duration = 1;
     */
    advanceDuration: bigint;
}


/**
 * Adds elements to the stream to be emitted.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.TestStreamPayload.Event.AddElements
 */
export interface TestStreamPayload_Event_AddElements {
    /**
     * (Required) The elements to add to the TestStream.
     *
     * @generated from protobuf field: repeated org.apache.beam.model.pipeline.v1.TestStreamPayload.TimestampedElement elements = 1;
     */
    elements: TestStreamPayload_TimestampedElement[];
    /**
     * (Optional) The output PCollection tag to add these elements to. If
     * unspecified or with an empty string, this will default to the Main
     * PCollection Output.
     *
     * @generated from protobuf field: string tag = 3;
     */
    tag: string;
}


/**
 * A single element inside of the TestStream.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.TestStreamPayload.TimestampedElement
 */
export interface TestStreamPayload_TimestampedElement {
    /**
     * (Required) The element encoded. Currently the TestStream only supports
     * encoding primitives.
     *
     * @generated from protobuf field: bytes encoded_element = 1;
     */
    encodedElement: Uint8Array;
    /**
     * (Required) The event timestamp in millisecond of this element.
     *
     * @generated from protobuf field: int64 timestamp = 2;
     */
    timestamp: bigint;
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.EventsRequest
 */
export interface EventsRequest {
    /**
     * The set of PCollections to read from. These are the PTransform outputs
     * local names. These are a subset of the TestStream's outputs. This allows
     * Interactive Beam to cache many PCollections from a pipeline then replay a
     * subset of them.
     *
     * @generated from protobuf field: repeated string output_ids = 1;
     */
    outputIds: string[];
}


/**
 * The payload for the special-but-not-primitive WriteFiles transform.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.WriteFilesPayload
 */
export interface WriteFilesPayload {
    /**
     * (Required) The FunctionSpec of the FileBasedSink.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.FunctionSpec sink = 1;
     */
    sink?: FunctionSpec;
    /**
     * (Required) The format function.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.FunctionSpec format_function = 2;
     */
    formatFunction?: FunctionSpec;
    /**
     * @generated from protobuf field: bool windowed_writes = 3;
     */
    windowedWrites: boolean;
    /**
     * @generated from protobuf field: bool runner_determined_sharding = 4;
     */
    runnerDeterminedSharding: boolean;
    /**
     * @generated from protobuf field: map<string, org.apache.beam.model.pipeline.v1.SideInput> side_inputs = 5;
     */
    sideInputs: {
        [key: string]: SideInput;
    };
}


/**
 * Payload used by Google Cloud Pub/Sub read transform.
 * This can be used by runners that wish to override Beam Pub/Sub read transform
 * with a native implementation.
 * The SDK should guarantee that only one of topic, subscription,
 * topic_runtime_overridden and subscription_runtime_overridden is set.
 * The output of PubSubReadPayload should be bytes of serialized PubsubMessage
 * proto if with_attributes == true. Otherwise, the bytes is the raw payload.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.PubSubReadPayload
 */
export interface PubSubReadPayload {
    /**
     * Topic to read from. Exactly one of topic or subscription should be set.
     * Topic format is: /topics/project_id/subscription_name
     *
     * @generated from protobuf field: string topic = 1;
     */
    topic: string;
    /**
     * Subscription to read from. Exactly one of topic or subscription should be set.
     * Subscription format is: /subscriptions/project_id/subscription_name
     *
     * @generated from protobuf field: string subscription = 2;
     */
    subscription: string;
    /**
     * Attribute that provides element timestamps.
     *
     * @generated from protobuf field: string timestamp_attribute = 3;
     */
    timestampAttribute: string;
    /**
     * Attribute to be used for uniquely identifying messages.
     *
     * @generated from protobuf field: string id_attribute = 4;
     */
    idAttribute: string;
    /**
     * If true, reads Pub/Sub payload as well as attributes. If false, reads only the payload.
     *
     * @generated from protobuf field: bool with_attributes = 5;
     */
    withAttributes: boolean;
    /**
     * If set, the topic is expected to be provided during runtime.
     *
     * @generated from protobuf field: string topic_runtime_overridden = 6;
     */
    topicRuntimeOverridden: string;
    /**
     * If set, the subscription that is expected to be provided during runtime.
     *
     * @generated from protobuf field: string subscription_runtime_overridden = 7;
     */
    subscriptionRuntimeOverridden: string;
}


/**
 * Payload used by Google Cloud Pub/Sub write transform.
 * This can be used by runners that wish to override Beam Pub/Sub write transform
 * with a native implementation.
 * The SDK should guarantee that only one of topic and topic_runtime_overridden
 * is set.
 * The output of PubSubWritePayload should be bytes if serialized PubsubMessage
 * proto.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.PubSubWritePayload
 */
export interface PubSubWritePayload {
    /**
     * Topic to write to.
     * Topic format is: /topics/project_id/subscription_name
     *
     * @generated from protobuf field: string topic = 1;
     */
    topic: string;
    /**
     * Attribute that provides element timestamps.
     *
     * @generated from protobuf field: string timestamp_attribute = 2;
     */
    timestampAttribute: string;
    /**
     * Attribute that uniquely identify messages.
     *
     * @generated from protobuf field: string id_attribute = 3;
     */
    idAttribute: string;
    /**
     * If set, the topic is expected to be provided during runtime.
     *
     * @generated from protobuf field: string topic_runtime_overridden = 4;
     */
    topicRuntimeOverridden: string;
}


/**
 * Payload for GroupIntoBatches composite transform.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.GroupIntoBatchesPayload
 */
export interface GroupIntoBatchesPayload {
    /**
     * Max size of a batch.
     *
     * @generated from protobuf field: int64 batch_size = 1;
     */
    batchSize: bigint;
    /**
     * Max byte size of a batch in element.
     *
     * @generated from protobuf field: int64 batch_size_bytes = 3;
     */
    batchSizeBytes: bigint;
    /**
     * (Optional) Max duration a batch is allowed to be cached in states.
     *
     * @generated from protobuf field: int64 max_buffering_duration_millis = 2;
     */
    maxBufferingDurationMillis: bigint;
}


/**
 * A coder, the binary format for serialization and deserialization of data in
 * a pipeline.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.Coder
 */
export interface Coder {
    /**
     * (Required) A specification for the coder, as a URN plus parameters. This
     * may be a cross-language agreed-upon format, or it may be a "custom coder"
     * that can only be used by a particular SDK. It does not include component
     * coders, as it is beneficial for these to be comprehensible to a runner
     * regardless of whether the binary format is agreed-upon.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.FunctionSpec spec = 1;
     */
    spec?: FunctionSpec;
    /**
     * (Optional) If this coder is parametric, such as ListCoder(VarIntCoder),
     * this is a list of the components. In order for encodings to be identical,
     * the FunctionSpec and all components must be identical, recursively.
     *
     * @generated from protobuf field: repeated string component_coder_ids = 2;
     */
    componentCoderIds: string[];
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.StandardCoders
 */
export interface StandardCoders {
}


/**
 * A windowing strategy describes the window function, triggering, allowed
 * lateness, and accumulation mode for a PCollection.
 *
 * TODO: consider inlining field on PCollection
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.WindowingStrategy
 */
export interface WindowingStrategy {
    /**
     * (Required) The FunctionSpec of the UDF that assigns windows,
     * merges windows, and shifts timestamps before they are
     * combined according to the OutputTime.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.FunctionSpec window_fn = 1;
     */
    windowFn?: FunctionSpec;
    /**
     * (Required) Whether or not the window fn is merging.
     *
     * This knowledge is required for many optimizations.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.MergeStatus.Enum merge_status = 2;
     */
    mergeStatus: MergeStatus_Enum;
    /**
     * (Required) The coder for the windows of this PCollection.
     *
     * @generated from protobuf field: string window_coder_id = 3;
     */
    windowCoderId: string;
    /**
     * (Required) The trigger to use when grouping this PCollection.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Trigger trigger = 4;
     */
    trigger?: Trigger;
    /**
     * (Required) The accumulation mode indicates whether new panes are a full
     * replacement for prior panes or whether they are deltas to be combined
     * with other panes (the combine should correspond to whatever the upstream
     * grouping transform is).
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.AccumulationMode.Enum accumulation_mode = 5;
     */
    accumulationMode: AccumulationMode_Enum;
    /**
     * (Required) The OutputTime specifies, for a grouping transform, how to
     * compute the aggregate timestamp. The window_fn will first possibly shift
     * it later, then the OutputTime takes the max, min, or ignores it and takes
     * the end of window.
     *
     * This is actually only for input to grouping transforms, but since they
     * may be introduced in runner-specific ways, it is carried along with the
     * windowing strategy.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.OutputTime.Enum output_time = 6;
     */
    outputTime: OutputTime_Enum;
    /**
     * (Required) Indicate when output should be omitted upon window expiration.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.ClosingBehavior.Enum closing_behavior = 7;
     */
    closingBehavior: ClosingBehavior_Enum;
    /**
     * (Required) The duration, in milliseconds, beyond the end of a window at
     * which the window becomes droppable.
     *
     * @generated from protobuf field: int64 allowed_lateness = 8;
     */
    allowedLateness: bigint;
    /**
     * (Required) Indicate whether empty on-time panes should be omitted.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.OnTimeBehavior.Enum on_time_behavior = 9;
     */
    onTimeBehavior: OnTimeBehavior_Enum;
    /**
     * (Required) Whether or not the window fn assigns inputs to exactly one window
     *
     * This knowledge is required for some optimizations
     *
     * @generated from protobuf field: bool assigns_to_one_window = 10;
     */
    assignsToOneWindow: boolean;
    /**
     * (Optional) Environment where the current window_fn should be applied in.
     * Runner that executes the pipeline may choose to override this if needed.
     * If not specified, environment will be decided by the runner.
     *
     * @generated from protobuf field: string environment_id = 11;
     */
    environmentId: string;
}


/**
 * Whether or not a PCollection's WindowFn is non-merging, merging, or
 * merging-but-already-merged, in which case a subsequent GroupByKey is almost
 * always going to do something the user does not want
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.MergeStatus
 */
export interface MergeStatus {
}


/**
 * Whether or not subsequent outputs of aggregations should be entire
 * replacement values or just the aggregation of inputs received since
 * the prior output.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.AccumulationMode
 */
export interface AccumulationMode {
}


/**
 * Controls whether or not an aggregating transform should output data
 * when a window expires.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.ClosingBehavior
 */
export interface ClosingBehavior {
}


/**
 * Controls whether or not an aggregating transform should output data
 * when an on-time pane is empty.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.OnTimeBehavior
 */
export interface OnTimeBehavior {
}


/**
 * When a number of windowed, timestamped inputs are aggregated, the timestamp
 * for the resulting output.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.OutputTime
 */
export interface OutputTime {
}


/**
 * The different time domains in the Beam model.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.TimeDomain
 */
export interface TimeDomain {
}


/**
 * A small DSL for expressing when to emit new aggregations
 * from a GroupByKey or CombinePerKey
 *
 * A trigger is described in terms of when it is _ready_ to permit output.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.Trigger
 */
export interface Trigger {
    /**
     * @generated from protobuf oneof: trigger
     */
    trigger: {
        oneofKind: "afterAll";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Trigger.AfterAll after_all = 1;
         */
        afterAll: Trigger_AfterAll;
    } | {
        oneofKind: "afterAny";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Trigger.AfterAny after_any = 2;
         */
        afterAny: Trigger_AfterAny;
    } | {
        oneofKind: "afterEach";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Trigger.AfterEach after_each = 3;
         */
        afterEach: Trigger_AfterEach;
    } | {
        oneofKind: "afterEndOfWindow";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Trigger.AfterEndOfWindow after_end_of_window = 4;
         */
        afterEndOfWindow: Trigger_AfterEndOfWindow;
    } | {
        oneofKind: "afterProcessingTime";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Trigger.AfterProcessingTime after_processing_time = 5;
         */
        afterProcessingTime: Trigger_AfterProcessingTime;
    } | {
        oneofKind: "afterSynchronizedProcessingTime";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Trigger.AfterSynchronizedProcessingTime after_synchronized_processing_time = 6;
         */
        afterSynchronizedProcessingTime: Trigger_AfterSynchronizedProcessingTime;
    } | {
        oneofKind: "always";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Trigger.Always always = 12;
         */
        always: Trigger_Always;
    } | {
        oneofKind: "default";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Trigger.Default default = 7;
         */
        default: Trigger_Default;
    } | {
        oneofKind: "elementCount";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Trigger.ElementCount element_count = 8;
         */
        elementCount: Trigger_ElementCount;
    } | {
        oneofKind: "never";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Trigger.Never never = 9;
         */
        never: Trigger_Never;
    } | {
        oneofKind: "orFinally";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Trigger.OrFinally or_finally = 10;
         */
        orFinally: Trigger_OrFinally;
    } | {
        oneofKind: "repeat";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Trigger.Repeat repeat = 11;
         */
        repeat: Trigger_Repeat;
    } | {
        oneofKind: undefined;
    };
}


/**
 * Ready when all subtriggers are ready.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.Trigger.AfterAll
 */
export interface Trigger_AfterAll {
    /**
     * @generated from protobuf field: repeated org.apache.beam.model.pipeline.v1.Trigger subtriggers = 1;
     */
    subtriggers: Trigger[];
}


/**
 * Ready when any subtrigger is ready.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.Trigger.AfterAny
 */
export interface Trigger_AfterAny {
    /**
     * @generated from protobuf field: repeated org.apache.beam.model.pipeline.v1.Trigger subtriggers = 1;
     */
    subtriggers: Trigger[];
}


/**
 * Starting with the first subtrigger, ready when the _current_ subtrigger
 * is ready. After output, advances the current trigger by one.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.Trigger.AfterEach
 */
export interface Trigger_AfterEach {
    /**
     * @generated from protobuf field: repeated org.apache.beam.model.pipeline.v1.Trigger subtriggers = 1;
     */
    subtriggers: Trigger[];
}


/**
 * Ready after the input watermark is past the end of the window.
 *
 * May have implicitly-repeated subtriggers for early and late firings.
 * When the end of the window is reached, the trigger transitions between
 * the subtriggers.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.Trigger.AfterEndOfWindow
 */
export interface Trigger_AfterEndOfWindow {
    /**
     * (Optional) A trigger governing output prior to the end of the window.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Trigger early_firings = 1;
     */
    earlyFirings?: Trigger;
    /**
     * (Optional) A trigger governing output after the end of the window.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Trigger late_firings = 2;
     */
    lateFirings?: Trigger;
}


/**
 * After input arrives, ready when the specified delay has passed.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.Trigger.AfterProcessingTime
 */
export interface Trigger_AfterProcessingTime {
    /**
     * (Required) The transforms to apply to an arriving element's timestamp,
     * in order
     *
     * @generated from protobuf field: repeated org.apache.beam.model.pipeline.v1.TimestampTransform timestamp_transforms = 1;
     */
    timestampTransforms: TimestampTransform[];
}


/**
 * Ready whenever upstream processing time has all caught up with
 * the arrival time of an input element
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.Trigger.AfterSynchronizedProcessingTime
 */
export interface Trigger_AfterSynchronizedProcessingTime {
}


/**
 * The default trigger. Equivalent to Repeat { AfterEndOfWindow } but
 * specially denoted to indicate the user did not alter the triggering.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.Trigger.Default
 */
export interface Trigger_Default {
}


/**
 * Ready whenever the requisite number of input elements have arrived
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.Trigger.ElementCount
 */
export interface Trigger_ElementCount {
    /**
     * @generated from protobuf field: int32 element_count = 1;
     */
    elementCount: number;
}


/**
 * Never ready. There will only be an ON_TIME output and a final
 * output at window expiration.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.Trigger.Never
 */
export interface Trigger_Never {
}


/**
 * Always ready. This can also be expressed as ElementCount(1) but
 * is more explicit.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.Trigger.Always
 */
export interface Trigger_Always {
}


/**
 * Ready whenever either of its subtriggers are ready, but finishes output
 * when the finally subtrigger fires.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.Trigger.OrFinally
 */
export interface Trigger_OrFinally {
    /**
     * (Required) Trigger governing main output; may fire repeatedly.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Trigger main = 1;
     */
    main?: Trigger;
    /**
     * (Required) Trigger governing termination of output.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Trigger finally = 2;
     */
    finally?: Trigger;
}


/**
 * Ready whenever the subtrigger is ready; resets state when the subtrigger
 * completes.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.Trigger.Repeat
 */
export interface Trigger_Repeat {
    /**
     * (Require) Trigger that is run repeatedly.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Trigger subtrigger = 1;
     */
    subtrigger?: Trigger;
}


/**
 * A specification for a transformation on a timestamp.
 *
 * Primarily used by AfterProcessingTime triggers to transform
 * the arrival time of input to a target time for firing.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.TimestampTransform
 */
export interface TimestampTransform {
    /**
     * @generated from protobuf oneof: timestamp_transform
     */
    timestampTransform: {
        oneofKind: "delay";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.TimestampTransform.Delay delay = 1;
         */
        delay: TimestampTransform_Delay;
    } | {
        oneofKind: "alignTo";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.TimestampTransform.AlignTo align_to = 2;
         */
        alignTo: TimestampTransform_AlignTo;
    } | {
        oneofKind: undefined;
    };
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.TimestampTransform.Delay
 */
export interface TimestampTransform_Delay {
    /**
     * (Required) The delay, in milliseconds.
     *
     * @generated from protobuf field: int64 delay_millis = 1;
     */
    delayMillis: bigint;
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.TimestampTransform.AlignTo
 */
export interface TimestampTransform_AlignTo {
    /**
     * (Required) A duration to which delays should be quantized
     * in milliseconds.
     *
     * @generated from protobuf field: int64 period = 3;
     */
    period: bigint;
    /**
     * (Required) An offset from 0 for the quantization specified by
     * alignment_size, in milliseconds
     *
     * @generated from protobuf field: int64 offset = 4;
     */
    offset: bigint;
}


/**
 * A specification for how to "side input" a PCollection.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.SideInput
 */
export interface SideInput {
    /**
     * (Required) URN of the access pattern required by the `view_fn` to present
     * the desired SDK-specific interface to a UDF.
     *
     * This access pattern defines the SDK harness <-> Runner Harness RPC
     * interface for accessing a side input.
     *
     * The only access pattern intended for Beam, because of its superior
     * performance possibilities, is "beam:sideinput:multimap" (or some such
     * URN)
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.FunctionSpec access_pattern = 1;
     */
    accessPattern?: FunctionSpec;
    /**
     * (Required) The FunctionSpec of the UDF that adapts a particular
     * access_pattern to a user-facing view type.
     *
     * For example, View.asSingleton() may include a `view_fn` that adapts a
     * specially-designed multimap to a single value per window.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.FunctionSpec view_fn = 2;
     */
    viewFn?: FunctionSpec;
    /**
     * (Required) The FunctionSpec of the UDF that maps a main input window
     * to a side input window.
     *
     * For example, when the main input is in fixed windows of one hour, this
     * can specify that the side input should be accessed according to the day
     * in which that hour falls.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.FunctionSpec window_mapping_fn = 3;
     */
    windowMappingFn?: FunctionSpec;
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.StandardArtifacts
 */
export interface StandardArtifacts {
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.ArtifactFilePayload
 */
export interface ArtifactFilePayload {
    /**
     * a string for an artifact file path e.g. "/tmp/foo.jar"
     *
     * @generated from protobuf field: string path = 1;
     */
    path: string;
    /**
     * The hex-encoded sha256 checksum of the artifact.
     *
     * @generated from protobuf field: string sha256 = 2;
     */
    sha256: string;
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.ArtifactUrlPayload
 */
export interface ArtifactUrlPayload {
    /**
     * a string for an artifact URL e.g. "https://.../foo.jar" or "gs://tmp/foo.jar"
     *
     * @generated from protobuf field: string url = 1;
     */
    url: string;
    /**
     * (Optional) The hex-encoded sha256 checksum of the artifact if available.
     *
     * @generated from protobuf field: string sha256 = 2;
     */
    sha256: string;
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.EmbeddedFilePayload
 */
export interface EmbeddedFilePayload {
    /**
     * raw data bytes for an embedded artifact
     *
     * @generated from protobuf field: bytes data = 1;
     */
    data: Uint8Array;
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.PyPIPayload
 */
export interface PyPIPayload {
    /**
     * Pypi compatible artifact id e.g. "apache-beam"
     *
     * @generated from protobuf field: string artifact_id = 1;
     */
    artifactId: string;
    /**
     * Pypi compatible version string.
     *
     * @generated from protobuf field: string version = 2;
     */
    version: string;
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.MavenPayload
 */
export interface MavenPayload {
    /**
     * A string specifying Maven artifact.
     * The standard format is "groupId:artifactId:version[:packaging[:classifier]]"
     *
     * @generated from protobuf field: string artifact = 1;
     */
    artifact: string;
    /**
     * (Optional) Repository URL. If not specified, Maven central is used by default.
     *
     * @generated from protobuf field: string repository_url = 2;
     */
    repositoryUrl: string;
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.DeferredArtifactPayload
 */
export interface DeferredArtifactPayload {
    /**
     * A unique string identifier assigned by the creator of this payload. The creator may use this key to confirm
     * whether they can parse the data.
     *
     * @generated from protobuf field: string key = 1;
     */
    key: string;
    /**
     * Data for deferred artifacts. Interpretation of bytes is delegated to the creator of this payload.
     *
     * @generated from protobuf field: bytes data = 2;
     */
    data: Uint8Array;
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.ArtifactStagingToRolePayload
 */
export interface ArtifactStagingToRolePayload {
    /**
     * A generated staged name (relative path under staging directory).
     *
     * @generated from protobuf field: string staged_name = 1;
     */
    stagedName: string;
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.ArtifactInformation
 */
export interface ArtifactInformation {
    /**
     * A URN that describes the type of artifact
     *
     * @generated from protobuf field: string type_urn = 1;
     */
    typeUrn: string;
    /**
     * @generated from protobuf field: bytes type_payload = 2;
     */
    typePayload: Uint8Array;
    /**
     * A URN that describes the role of artifact
     *
     * @generated from protobuf field: string role_urn = 3;
     */
    roleUrn: string;
    /**
     * @generated from protobuf field: bytes role_payload = 4;
     */
    rolePayload: Uint8Array;
}


/**
 * An environment for executing UDFs. By default, an SDK container URL, but
 * can also be a process forked by a command, or an externally managed process.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.Environment
 */
export interface Environment {
    /**
     * (Required) The URN of the payload
     *
     * @generated from protobuf field: string urn = 2;
     */
    urn: string;
    /**
     * (Optional) The data specifying any parameters to the URN. If
     * the URN does not require any arguments, this may be omitted.
     *
     * @generated from protobuf field: bytes payload = 3;
     */
    payload: Uint8Array;
    /**
     * (Optional) Static display data for the environment. If there is none,
     * it may be omitted.
     *
     * @generated from protobuf field: repeated org.apache.beam.model.pipeline.v1.DisplayData display_data = 4;
     */
    displayData: DisplayData[];
    /**
     * (Optional) A set of capabilities this environment supports. This is
     * typically a list of common URNs designating coders, transforms, etc. that
     * this environment understands (and a runner MAY use) despite not
     * appearing in the pipeline proto. This may also be used to indicate
     * support of optional protocols not tied to a concrete component.
     *
     * @generated from protobuf field: repeated string capabilities = 5;
     */
    capabilities: string[];
    /**
     * (Optional) artifact dependency information used for executing UDFs in this environment.
     *
     * @generated from protobuf field: repeated org.apache.beam.model.pipeline.v1.ArtifactInformation dependencies = 6;
     */
    dependencies: ArtifactInformation[];
    /**
     * (Optional) A mapping of resource URNs to requested values.  The encoding
     * of the values is specified by the URN.  Resource hints are advisory;
     * a runner is free to ignore resource hints that it does not understand.
     *
     * @generated from protobuf field: map<string, bytes> resource_hints = 7;
     */
    resourceHints: {
        [key: string]: Uint8Array;
    };
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.StandardEnvironments
 */
export interface StandardEnvironments {
}


/**
 * The payload of a Docker image
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.DockerPayload
 */
export interface DockerPayload {
    /**
     * @generated from protobuf field: string container_image = 1;
     */
    containerImage: string; // implicitly linux_amd64.
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.ProcessPayload
 */
export interface ProcessPayload {
    /**
     * @generated from protobuf field: string os = 1;
     */
    os: string; // "linux", "darwin", ..
    /**
     * @generated from protobuf field: string arch = 2;
     */
    arch: string; // "amd64", ..
    /**
     * @generated from protobuf field: string command = 3;
     */
    command: string; // process to execute
    /**
     * @generated from protobuf field: map<string, string> env = 4;
     */
    env: {
        [key: string]: string;
    }; // Environment variables
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.ExternalPayload
 */
export interface ExternalPayload {
    /**
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.ApiServiceDescriptor endpoint = 1;
     */
    endpoint?: ApiServiceDescriptor;
    /**
     * @generated from protobuf field: map<string, string> params = 2;
     */
    params: {
        [key: string]: string;
    }; // Arbitrary extra parameters to pass
}


/**
 * These URNs are used to indicate capabilities of environments that cannot
 * simply be expressed as a component (such as a Coder or PTransform) that this
 * environment understands.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.StandardProtocols
 */
export interface StandardProtocols {
}


/**
 * These URNs are used to indicate capabilities of runner that an environment
 * may take advantage of when interacting with this runner.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.StandardRunnerProtocols
 */
export interface StandardRunnerProtocols {
}


/**
 * These URNs are used to indicate requirements of a pipeline that cannot
 * simply be expressed as a component (such as a Coder or PTransform) that the
 * runner must understand. In many cases, this indicates a particular field
 * of a transform must be inspected and respected (which allows new fields
 * to be added in a forwards-compatible way).
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.StandardRequirements
 */
export interface StandardRequirements {
}


/**
 * A URN along with a parameter object whose schema is determined by the
 * URN.
 *
 * This structure is reused in two distinct, but compatible, ways:
 *
 * 1. This can be a specification of the function over PCollections
 *    that a PTransform computes.
 * 2. This can be a specification of a user-defined function, possibly
 *    SDK-specific. (external to this message must be adequate context
 *    to indicate the environment in which the UDF can be understood).
 *
 * Though not explicit in this proto, there are two possibilities
 * for the relationship of a runner to this specification that
 * one should bear in mind:
 *
 * 1. The runner understands the URN. For example, it might be
 *    a well-known URN like "beam:transform:Top" or
 *    "beam:window_fn:FixedWindows" with
 *    an agreed-upon payload (e.g. a number or duration,
 *    respectively).
 * 2. The runner does not understand the URN. It might be an
 *    SDK specific URN such as "beam:dofn:javasdk:1.0"
 *    that indicates to the SDK what the payload is,
 *    such as a serialized Java DoFn from a particular
 *    version of the Beam Java SDK. The payload will often
 *    then be an opaque message such as bytes in a
 *    language-specific serialization format.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.FunctionSpec
 */
export interface FunctionSpec {
    /**
     * (Required) A URN that describes the accompanying payload.
     * For any URN that is not recognized (by whomever is inspecting
     * it) the parameter payload should be treated as opaque and
     * passed as-is.
     *
     * @generated from protobuf field: string urn = 1;
     */
    urn: string;
    /**
     * (Optional) The data specifying any parameters to the URN. If
     * the URN does not require any arguments, this may be omitted.
     *
     * @generated from protobuf field: bytes payload = 3;
     */
    payload: Uint8Array;
}


/**
 * A set of well known URNs describing display data.
 *
 * All descriptions must contain how the value should be classified and how it
 * is encoded. Note that some types are logical types which convey contextual
 * information about the pipeline in addition to an encoding while others only
 * specify the encoding itself.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.StandardDisplayData
 */
export interface StandardDisplayData {
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.LabelledPayload
 */
export interface LabelledPayload {
    /**
     * (Required) A human readable label for the value.
     *
     * @generated from protobuf field: string label = 1;
     */
    label: string;
    /**
     * @generated from protobuf oneof: value
     */
    value: {
        oneofKind: "stringValue";
        /**
         * @generated from protobuf field: string string_value = 2;
         */
        stringValue: string;
    } | {
        oneofKind: "boolValue";
        /**
         * @generated from protobuf field: bool bool_value = 3;
         */
        boolValue: boolean;
    } | {
        oneofKind: "doubleValue";
        /**
         * @generated from protobuf field: double double_value = 4;
         */
        doubleValue: number;
    } | {
        oneofKind: "intValue";
        /**
         * @generated from protobuf field: int64 int_value = 5;
         */
        intValue: bigint;
    } | {
        oneofKind: undefined;
    };
    /**
     * (Required) The key identifies the actual content of the metadata.
     *
     * @generated from protobuf field: string key = 6;
     */
    key: string;
    /**
     * (Required) The namespace describes the context that specified the key.
     *
     * @generated from protobuf field: string namespace = 7;
     */
    namespace: string;
}


/**
 * Static display data associated with a pipeline component. Display data is
 * useful for pipeline runners IOs and diagnostic dashboards to display details
 * about annotated components.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.DisplayData
 */
export interface DisplayData {
    /**
     * A key used to describe the type of display data. See StandardDisplayData
     * for the set of well known urns describing how the payload is meant to be
     * interpreted.
     *
     * @generated from protobuf field: string urn = 1;
     */
    urn: string;
    /**
     * (Optional) The data specifying any parameters to the URN. If
     * the URN does not require any arguments, this may be omitted.
     *
     * @generated from protobuf field: bytes payload = 2;
     */
    payload: Uint8Array;
}


// The following transforms are not part of the RunnerApi specification,
// but may be useful for graph construction and manipulation.
/**
 * A disjoint union of all the things that may contain references
 * that require Components to resolve.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.MessageWithComponents
 */
export interface MessageWithComponents {
    /**
     * (Optional) The by-reference components of the root message,
     * enabling a standalone message.
     *
     * If this is absent, it is expected that there are no
     * references.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Components components = 1;
     */
    components?: Components;
    /**
     * @generated from protobuf oneof: root
     */
    root: {
        oneofKind: "coder";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Coder coder = 2;
         */
        coder: Coder;
    } | {
        oneofKind: "combinePayload";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.CombinePayload combine_payload = 3;
         */
        combinePayload: CombinePayload;
    } | {
        oneofKind: "functionSpec";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.FunctionSpec function_spec = 4;
         */
        functionSpec: FunctionSpec;
    } | {
        oneofKind: "parDoPayload";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.ParDoPayload par_do_payload = 6;
         */
        parDoPayload: ParDoPayload;
    } | {
        oneofKind: "ptransform";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.PTransform ptransform = 7;
         */
        ptransform: PTransform;
    } | {
        oneofKind: "pcollection";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.PCollection pcollection = 8;
         */
        pcollection: PCollection;
    } | {
        oneofKind: "readPayload";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.ReadPayload read_payload = 9;
         */
        readPayload: ReadPayload;
    } | {
        oneofKind: "sideInput";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.SideInput side_input = 11;
         */
        sideInput: SideInput;
    } | {
        oneofKind: "windowIntoPayload";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.WindowIntoPayload window_into_payload = 12;
         */
        windowIntoPayload: WindowIntoPayload;
    } | {
        oneofKind: "windowingStrategy";
        /**
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.WindowingStrategy windowing_strategy = 13;
         */
        windowingStrategy: WindowingStrategy;
    } | {
        oneofKind: undefined;
    };
}


/**
 * The payload for an executable stage. This will eventually be passed to an SDK in the form of a
 * ProcessBundleDescriptor.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.ExecutableStagePayload
 */
export interface ExecutableStagePayload {
    /**
     * (Required) Environment in which this stage executes.
     *
     * We use an environment rather than environment id
     * because ExecutableStages use environments directly. This may change in the future.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Environment environment = 1;
     */
    environment?: Environment;
    /**
     * The wire coder settings of this executable stage
     *
     * @generated from protobuf field: repeated org.apache.beam.model.pipeline.v1.ExecutableStagePayload.WireCoderSetting wire_coder_settings = 9;
     */
    wireCoderSettings: ExecutableStagePayload_WireCoderSetting[];
    /**
     * (Required) Input PCollection id. This must be present as a value in the inputs of any
     * PTransform the ExecutableStagePayload is the payload of.
     *
     * @generated from protobuf field: string input = 2;
     */
    input: string;
    /**
     * The side inputs required for this executable stage. Each side input of each PTransform within
     * this ExecutableStagePayload must be represented within this field.
     *
     * @generated from protobuf field: repeated org.apache.beam.model.pipeline.v1.ExecutableStagePayload.SideInputId side_inputs = 3;
     */
    sideInputs: ExecutableStagePayload_SideInputId[];
    /**
     * PTransform ids contained within this executable stage. This must contain at least one
     * PTransform id.
     *
     * @generated from protobuf field: repeated string transforms = 4;
     */
    transforms: string[];
    /**
     * Output PCollection ids. This must be equal to the values of the outputs of any
     * PTransform the ExecutableStagePayload is the payload of.
     *
     * @generated from protobuf field: repeated string outputs = 5;
     */
    outputs: string[];
    /**
     * (Required) The components for the Executable Stage. This must contain all of the Transforms
     * in transforms, and the closure of all of the components they recognize.
     *
     * @generated from protobuf field: org.apache.beam.model.pipeline.v1.Components components = 6;
     */
    components?: Components;
    /**
     * The user states required for this executable stage. Each user state of each PTransform within
     * this ExecutableStagePayload must be represented within this field.
     *
     * @generated from protobuf field: repeated org.apache.beam.model.pipeline.v1.ExecutableStagePayload.UserStateId user_states = 7;
     */
    userStates: ExecutableStagePayload_UserStateId[];
    /**
     * The timers required for this executable stage. Each timer of each PTransform within
     * this ExecutableStagePayload must be represented within this field.
     *
     * @generated from protobuf field: repeated org.apache.beam.model.pipeline.v1.ExecutableStagePayload.TimerId timers = 8;
     */
    timers: ExecutableStagePayload_TimerId[];
    /**
     * The timerfamilies required for this executable stage. Each timer familyof each PTransform within
     * this ExecutableStagePayload must be represented within this field.
     *
     * @generated from protobuf field: repeated org.apache.beam.model.pipeline.v1.ExecutableStagePayload.TimerFamilyId timerFamilies = 10;
     */
    timerFamilies: ExecutableStagePayload_TimerFamilyId[];
}


/**
 * A reference to a side input. Side inputs are uniquely identified by PTransform id and
 * local name.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.ExecutableStagePayload.SideInputId
 */
export interface ExecutableStagePayload_SideInputId {
    /**
     * (Required) The id of the PTransform that references this side input.
     *
     * @generated from protobuf field: string transform_id = 1;
     */
    transformId: string;
    /**
     * (Required) The local name of this side input from the PTransform that references it.
     *
     * @generated from protobuf field: string local_name = 2;
     */
    localName: string;
}


/**
 * A reference to user state. User states are uniquely identified by PTransform id and
 * local name.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.ExecutableStagePayload.UserStateId
 */
export interface ExecutableStagePayload_UserStateId {
    /**
     * (Required) The id of the PTransform that references this user state.
     *
     * @generated from protobuf field: string transform_id = 1;
     */
    transformId: string;
    /**
     * (Required) The local name of this user state for the PTransform that references it.
     *
     * @generated from protobuf field: string local_name = 2;
     */
    localName: string;
}


/**
 * A reference to a timer. Timers are uniquely identified by PTransform id and
 * local name.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.ExecutableStagePayload.TimerId
 */
export interface ExecutableStagePayload_TimerId {
    /**
     * (Required) The id of the PTransform that references this timer.
     *
     * @generated from protobuf field: string transform_id = 1;
     */
    transformId: string;
    /**
     * (Required) The local name of this timer for the PTransform that references it.
     *
     * @generated from protobuf field: string local_name = 2;
     */
    localName: string;
}


/**
 * A reference to a timer. Timers are uniquely identified by PTransform id and
 * local name.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.ExecutableStagePayload.TimerFamilyId
 */
export interface ExecutableStagePayload_TimerFamilyId {
    /**
     * (Required) The id of the PTransform that references this timer family.
     *
     * @generated from protobuf field: string transform_id = 1;
     */
    transformId: string;
    /**
     * (Required) The local name of this timer family for the PTransform that references it.
     *
     * @generated from protobuf field: string local_name = 2;
     */
    localName: string;
}


/**
 * Settings that decide the coder type of wire coder.
 *
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.ExecutableStagePayload.WireCoderSetting
 */
export interface ExecutableStagePayload_WireCoderSetting {
    /**
     * (Required) The URN of the wire coder.
     * Note that only windowed value coder or parameterized windowed value coder are supported.
     *
     * @generated from protobuf field: string urn = 1;
     */
    urn: string;
    /**
     * (Optional) The data specifying any parameters to the URN. If
     * the URN is beam:coder:windowed_value:v1, this may be omitted. If the URN is
     * beam:coder:param_windowed_value:v1, the payload is an encoded windowed
     * value using the beam:coder:windowed_value:v1 coder parameterized by
     * a beam:coder:bytes:v1 element coder and the window coder that this
     * param_windowed_value coder uses.
     *
     * @generated from protobuf field: bytes payload = 2;
     */
    payload: Uint8Array;
    /**
     * @generated from protobuf oneof: target
     */
    target: {
        oneofKind: "inputOrOutputId";
        /**
         * The input or output PCollection id this setting applies to.
         *
         * @generated from protobuf field: string input_or_output_id = 3;
         */
        inputOrOutputId: string;
    } | {
        oneofKind: "timer";
        /**
         * The timer id this setting applies to.
         *
         * @generated from protobuf field: org.apache.beam.model.pipeline.v1.ExecutableStagePayload.TimerId timer = 4;
         */
        timer: ExecutableStagePayload_TimerId;
    } | {
        oneofKind: undefined;
    };
}


/**
 * @generated from protobuf message org.apache.beam.model.pipeline.v1.StandardResourceHints
 */
export interface StandardResourceHints {
}


/**
 * All timestamps in milliseconds since Jan 1, 1970.
 *
 * @generated from protobuf enum org.apache.beam.model.pipeline.v1.BeamConstants.Constants
 */
export enum BeamConstants_Constants {
    /**
     * All timestamps of elements or window boundaries must be within
     * the interval [MIN_TIMESTAMP_MILLIS, MAX_TIMESTAMP_MILLIS].
     * The smallest representable timestamp of an element or a window boundary.
     *
     * @generated from protobuf enum value: MIN_TIMESTAMP_MILLIS = 0;
     */
    MIN_TIMESTAMP_MILLIS = 0,
    /**
     * The largest representable timestamp of an element or a window boundary.
     *
     * @generated from protobuf enum value: MAX_TIMESTAMP_MILLIS = 1;
     */
    MAX_TIMESTAMP_MILLIS = 1,
    /**
     * The maximum timestamp for the global window.
     * Triggers use max timestamp to set timers' timestamp. Timers fire when
     * the watermark passes their timestamps. So, the timestamp needs to be
     * smaller than the MAX_TIMESTAMP_MILLIS.
     * One standard day is subtracted from MAX_TIMESTAMP_MILLIS to make sure
     * the max timestamp is smaller than MAX_TIMESTAMP_MILLIS even after rounding up
     * to seconds or minutes.
     *
     * @generated from protobuf enum value: GLOBAL_WINDOW_MAX_TIMESTAMP_MILLIS = 2;
     */
    GLOBAL_WINDOW_MAX_TIMESTAMP_MILLIS = 2
}