@flyteorg/flyteidl/gen/pb-js/flyteidl.d.ts

Compiled protocol buffers and gRPC service clients/servers for Flyte IDLs

import * as $protobuf from "protobufjs";
/** Namespace flyteidl. */
export namespace flyteidl {

    /** Namespace core. */
    namespace core {

        /** Properties of an ArtifactKey. */
        interface IArtifactKey {

            /** ArtifactKey project */
            project?: (string|null);

            /** ArtifactKey domain */
            domain?: (string|null);

            /** ArtifactKey name */
            name?: (string|null);

            /** ArtifactKey org */
            org?: (string|null);
        }

        /** Represents an ArtifactKey. */
        class ArtifactKey implements IArtifactKey {

            /**
             * Constructs a new ArtifactKey.
             * @param [properties] Properties to set
             */
            constructor(properties?: flyteidl.core.IArtifactKey);

            /** ArtifactKey project. */
            public project: string;

            /** ArtifactKey domain. */
            public domain: string;

            /** ArtifactKey name. */
            public name: string;

            /** ArtifactKey org. */
            public org: string;

            /**
             * Creates a new ArtifactKey instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ArtifactKey instance
             */
            public static create(properties?: flyteidl.core.IArtifactKey): flyteidl.core.ArtifactKey;

            /**
             * Encodes the specified ArtifactKey message. Does not implicitly {@link flyteidl.core.ArtifactKey.verify|verify} messages.
             * @param message ArtifactKey message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: flyteidl.core.IArtifactKey, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an ArtifactKey message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ArtifactKey
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.ArtifactKey;

            /**
             * Verifies an ArtifactKey message.
             * @param message Plain object to verify
             * @returns `null` if valid, otherwise the reason why it is not
             */
            public static verify(message: { [k: string]: any }): (string|null);
        }

        /** Properties of an ArtifactBindingData. */
        interface IArtifactBindingData {

            /** ArtifactBindingData partitionKey */
            partitionKey?: (string|null);

            /** ArtifactBindingData bindToTimePartition */
            bindToTimePartition?: (boolean|null);

            /** ArtifactBindingData timeTransform */
            timeTransform?: (flyteidl.core.ITimeTransform|null);
        }

        /** Represents an ArtifactBindingData. */
        class ArtifactBindingData implements IArtifactBindingData {

            /**
             * Constructs a new ArtifactBindingData.
             * @param [properties] Properties to set
             */
            constructor(properties?: flyteidl.core.IArtifactBindingData);

            /** ArtifactBindingData partitionKey. */
            public partitionKey: string;

            /** ArtifactBindingData bindToTimePartition. */
            public bindToTimePartition: boolean;

            /** ArtifactBindingData timeTransform. */
            public timeTransform?: (flyteidl.core.ITimeTransform|null);

            /** ArtifactBindingData partitionData. */
            public partitionData?: ("partitionKey"|"bindToTimePartition");

            /**
             * Creates a new ArtifactBindingData instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ArtifactBindingData instance
             */
            public static create(properties?: flyteidl.core.IArtifactBindingData): flyteidl.core.ArtifactBindingData;

            /**
             * Encodes the specified ArtifactBindingData message. Does not implicitly {@link flyteidl.core.ArtifactBindingData.verify|verify} messages.
             * @param message ArtifactBindingData message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: flyteidl.core.IArtifactBindingData, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an ArtifactBindingData message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ArtifactBindingData
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.ArtifactBindingData;

            /**
             * Verifies an ArtifactBindingData message.
             * @param message Plain object to verify
             * @returns `null` if valid, otherwise the reason why it is not
             */
            public static verify(message: { [k: string]: any }): (string|null);
        }

        /** Granularity enum. */
        enum Granularity {
            UNSET = 0,
            MINUTE = 1,
            HOUR = 2,
            DAY = 3,
            MONTH = 4
        }

        /** Operator enum. */
        enum Operator {
            MINUS = 0,
            PLUS = 1
        }

        /** Properties of a TimeTransform. */
        interface ITimeTransform {

            /** TimeTransform transform */
            transform?: (string|null);

            /** TimeTransform op */
            op?: (flyteidl.core.Operator|null);
        }

        /** Represents a TimeTransform. */
        class TimeTransform implements ITimeTransform {

            /**
             * Constructs a new TimeTransform.
             * @param [properties] Properties to set
             */
            constructor(properties?: flyteidl.core.ITimeTransform);

            /** TimeTransform transform. */
            public transform: string;

            /** TimeTransform op. */
            public op: flyteidl.core.Operator;

            /**
             * Creates a new TimeTransform instance using the specified properties.
             * @param [properties] Properties to set
             * @returns TimeTransform instance
             */
            public static create(properties?: flyteidl.core.ITimeTransform): flyteidl.core.TimeTransform;

            /**
             * Encodes the specified TimeTransform message. Does not implicitly {@link flyteidl.core.TimeTransform.verify|verify} messages.
             * @param message TimeTransform message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: flyteidl.core.ITimeTransform, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a TimeTransform message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns TimeTransform
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.TimeTransform;

            /**
             * Verifies a TimeTransform message.
             * @param message Plain object to verify
             * @returns `null` if valid, otherwise the reason why it is not
             */
            public static verify(message: { [k: string]: any }): (string|null);
        }

        /** Properties of an InputBindingData. */
        interface IInputBindingData {

            /** InputBindingData var */
            "var"?: (string|null);
        }

        /** Represents an InputBindingData. */
        class InputBindingData implements IInputBindingData {

            /**
             * Constructs a new InputBindingData.
             * @param [properties] Properties to set
             */
            constructor(properties?: flyteidl.core.IInputBindingData);

            /** InputBindingData var. */
            public var: string;

            /**
             * Creates a new InputBindingData instance using the specified properties.
             * @param [properties] Properties to set
             * @returns InputBindingData instance
             */
            public static create(properties?: flyteidl.core.IInputBindingData): flyteidl.core.InputBindingData;

            /**
             * Encodes the specified InputBindingData message. Does not implicitly {@link flyteidl.core.InputBindingData.verify|verify} messages.
             * @param message InputBindingData message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: flyteidl.core.IInputBindingData, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an InputBindingData message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns InputBindingData
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.InputBindingData;

            /**
             * Verifies an InputBindingData message.
             * @param message Plain object to verify
             * @returns `null` if valid, otherwise the reason why it is not
             */
            public static verify(message: { [k: string]: any }): (string|null);
        }

        /** Properties of a RuntimeBinding. */
        interface IRuntimeBinding {
        }

        /** Represents a RuntimeBinding. */
        class RuntimeBinding implements IRuntimeBinding {

            /**
             * Constructs a new RuntimeBinding.
             * @param [properties] Properties to set
             */
            constructor(properties?: flyteidl.core.IRuntimeBinding);

            /**
             * Creates a new RuntimeBinding instance using the specified properties.
             * @param [properties] Properties to set
             * @returns RuntimeBinding instance
             */
            public static create(properties?: flyteidl.core.IRuntimeBinding): flyteidl.core.RuntimeBinding;

            /**
             * Encodes the specified RuntimeBinding message. Does not implicitly {@link flyteidl.core.RuntimeBinding.verify|verify} messages.
             * @param message RuntimeBinding message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: flyteidl.core.IRuntimeBinding, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a RuntimeBinding message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns RuntimeBinding
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.RuntimeBinding;

            /**
             * Verifies a RuntimeBinding message.
             * @param message Plain object to verify
             * @returns `null` if valid, otherwise the reason why it is not
             */
            public static verify(message: { [k: string]: any }): (string|null);
        }

        /** Properties of a LabelValue. */
        interface ILabelValue {

            /** LabelValue staticValue */
            staticValue?: (string|null);

            /** LabelValue timeValue */
            timeValue?: (google.protobuf.ITimestamp|null);

            /** LabelValue triggeredBinding */
            triggeredBinding?: (flyteidl.core.IArtifactBindingData|null);

            /** LabelValue inputBinding */
            inputBinding?: (flyteidl.core.IInputBindingData|null);

            /** LabelValue runtimeBinding */
            runtimeBinding?: (flyteidl.core.IRuntimeBinding|null);
        }

        /** Represents a LabelValue. */
        class LabelValue implements ILabelValue {

            /**
             * Constructs a new LabelValue.
             * @param [properties] Properties to set
             */
            constructor(properties?: flyteidl.core.ILabelValue);

            /** LabelValue staticValue. */
            public staticValue: string;

            /** LabelValue timeValue. */
            public timeValue?: (google.protobuf.ITimestamp|null);

            /** LabelValue triggeredBinding. */
            public triggeredBinding?: (flyteidl.core.IArtifactBindingData|null);

            /** LabelValue inputBinding. */
            public inputBinding?: (flyteidl.core.IInputBindingData|null);

            /** LabelValue runtimeBinding. */
            public runtimeBinding?: (flyteidl.core.IRuntimeBinding|null);

            /** LabelValue value. */
            public value?: ("staticValue"|"timeValue"|"triggeredBinding"|"inputBinding"|"runtimeBinding");

            /**
             * Creates a new LabelValue instance using the specified properties.
             * @param [properties] Properties to set
             * @returns LabelValue instance
             */
            public static create(properties?: flyteidl.core.ILabelValue): flyteidl.core.LabelValue;

            /**
             * Encodes the specified LabelValue message. Does not implicitly {@link flyteidl.core.LabelValue.verify|verify} messages.
             * @param message LabelValue message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: flyteidl.core.ILabelValue, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a LabelValue message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns LabelValue
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.LabelValue;

            /**
             * Verifies a LabelValue message.
             * @param message Plain object to verify
             * @returns `null` if valid, otherwise the reason why it is not
             */
            public static verify(message: { [k: string]: any }): (string|null);
        }

        /** Properties of a Partitions. */
        interface IPartitions {

            /** Partitions value */
            value?: ({ [k: string]: flyteidl.core.ILabelValue }|null);
        }

        /** Represents a Partitions. */
        class Partitions implements IPartitions {

            /**
             * Constructs a new Partitions.
             * @param [properties] Properties to set
             */
            constructor(properties?: flyteidl.core.IPartitions);

            /** Partitions value. */
            public value: { [k: string]: flyteidl.core.ILabelValue };

            /**
             * Creates a new Partitions instance using the specified properties.
             * @param [properties] Properties to set
             * @returns Partitions instance
             */
            public static create(properties?: flyteidl.core.IPartitions): flyteidl.core.Partitions;

            /**
             * Encodes the specified Partitions message. Does not implicitly {@link flyteidl.core.Partitions.verify|verify} messages.
             * @param message Partitions message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: flyteidl.core.IPartitions, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a Partitions message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns Partitions
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.Partitions;

            /**
             * Verifies a Partitions message.
             * @param message Plain object to verify
             * @returns `null` if valid, otherwise the reason why it is not
             */
            public static verify(message: { [k: string]: any }): (string|null);
        }

        /** Properties of a TimePartition. */
        interface ITimePartition {

            /** TimePartition value */
            value?: (flyteidl.core.ILabelValue|null);

            /** TimePartition granularity */
            granularity?: (flyteidl.core.Granularity|null);
        }

        /** Represents a TimePartition. */
        class TimePartition implements ITimePartition {

            /**
             * Constructs a new TimePartition.
             * @param [properties] Properties to set
             */
            constructor(properties?: flyteidl.core.ITimePartition);

            /** TimePartition value. */
            public value?: (flyteidl.core.ILabelValue|null);

            /** TimePartition granularity. */
            public granularity: flyteidl.core.Granularity;

            /**
             * Creates a new TimePartition instance using the specified properties.
             * @param [properties] Properties to set
             * @returns TimePartition instance
             */
            public static create(properties?: flyteidl.core.ITimePartition): flyteidl.core.TimePartition;

            /**
             * Encodes the specified TimePartition message. Does not implicitly {@link flyteidl.core.TimePartition.verify|verify} messages.
             * @param message TimePartition message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: flyteidl.core.ITimePartition, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a TimePartition message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns TimePartition
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.TimePartition;

            /**
             * Verifies a TimePartition message.
             * @param message Plain object to verify
             * @returns `null` if valid, otherwise the reason why it is not
             */
            public static verify(message: { [k: string]: any }): (string|null);
        }

        /** Properties of an ArtifactID. */
        interface IArtifactID {

            /** ArtifactID artifactKey */
            artifactKey?: (flyteidl.core.IArtifactKey|null);

            /** ArtifactID version */
            version?: (string|null);

            /** ArtifactID partitions */
            partitions?: (flyteidl.core.IPartitions|null);

            /** ArtifactID timePartition */
            timePartition?: (flyteidl.core.ITimePartition|null);
        }

        /** Represents an ArtifactID. */
        class ArtifactID implements IArtifactID {

            /**
             * Constructs a new ArtifactID.
             * @param [properties] Properties to set
             */
            constructor(properties?: flyteidl.core.IArtifactID);

            /** ArtifactID artifactKey. */
            public artifactKey?: (flyteidl.core.IArtifactKey|null);

            /** ArtifactID version. */
            public version: string;

            /** ArtifactID partitions. */
            public partitions?: (flyteidl.core.IPartitions|null);

            /** ArtifactID timePartition. */
            public timePartition?: (flyteidl.core.ITimePartition|null);

            /**
             * Creates a new ArtifactID instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ArtifactID instance
             */
            public static create(properties?: flyteidl.core.IArtifactID): flyteidl.core.ArtifactID;

            /**
             * Encodes the specified ArtifactID message. Does not implicitly {@link flyteidl.core.ArtifactID.verify|verify} messages.
             * @param message ArtifactID message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: flyteidl.core.IArtifactID, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an ArtifactID message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ArtifactID
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.ArtifactID;

            /**
             * Verifies an ArtifactID message.
             * @param message Plain object to verify
             * @returns `null` if valid, otherwise the reason why it is not
             */
            public static verify(message: { [k: string]: any }): (string|null);
        }

        /** Properties of an ArtifactTag. */
        interface IArtifactTag {

            /** ArtifactTag artifactKey */
            artifactKey?: (flyteidl.core.IArtifactKey|null);

            /** ArtifactTag value */
            value?: (flyteidl.core.ILabelValue|null);
        }

        /** Represents an ArtifactTag. */
        class ArtifactTag implements IArtifactTag {

            /**
             * Constructs a new ArtifactTag.
             * @param [properties] Properties to set
             */
            constructor(properties?: flyteidl.core.IArtifactTag);

            /** ArtifactTag artifactKey. */
            public artifactKey?: (flyteidl.core.IArtifactKey|null);

            /** ArtifactTag value. */
            public value?: (flyteidl.core.ILabelValue|null);

            /**
             * Creates a new ArtifactTag instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ArtifactTag instance
             */
            public static create(properties?: flyteidl.core.IArtifactTag): flyteidl.core.ArtifactTag;

            /**
             * Encodes the specified ArtifactTag message. Does not implicitly {@link flyteidl.core.ArtifactTag.verify|verify} messages.
             * @param message ArtifactTag message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: flyteidl.core.IArtifactTag, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an ArtifactTag message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ArtifactTag
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.ArtifactTag;

            /**
             * Verifies an ArtifactTag message.
             * @param message Plain object to verify
             * @returns `null` if valid, otherwise the reason why it is not
             */
            public static verify(message: { [k: string]: any }): (string|null);
        }

        /** Properties of an ArtifactQuery. */
        interface IArtifactQuery {

            /** ArtifactQuery artifactId */
            artifactId?: (flyteidl.core.IArtifactID|null);

            /** ArtifactQuery artifactTag */
            artifactTag?: (flyteidl.core.IArtifactTag|null);

            /** ArtifactQuery uri */
            uri?: (string|null);

            /** ArtifactQuery binding */
            binding?: (flyteidl.core.IArtifactBindingData|null);
        }

        /** Represents an ArtifactQuery. */
        class ArtifactQuery implements IArtifactQuery {

            /**
             * Constructs a new ArtifactQuery.
             * @param [properties] Properties to set
             */
            constructor(properties?: flyteidl.core.IArtifactQuery);

            /** ArtifactQuery artifactId. */
            public artifactId?: (flyteidl.core.IArtifactID|null);

            /** ArtifactQuery artifactTag. */
            public artifactTag?: (flyteidl.core.IArtifactTag|null);

            /** ArtifactQuery uri. */
            public uri: string;

            /** ArtifactQuery binding. */
            public binding?: (flyteidl.core.IArtifactBindingData|null);

            /** ArtifactQuery identifier. */
            public identifier?: ("artifactId"|"artifactTag"|"uri"|"binding");

            /**
             * Creates a new ArtifactQuery instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ArtifactQuery instance
             */
            public static create(properties?: flyteidl.core.IArtifactQuery): flyteidl.core.ArtifactQuery;

            /**
             * Encodes the specified ArtifactQuery message. Does not implicitly {@link flyteidl.core.ArtifactQuery.verify|verify} messages.
             * @param message ArtifactQuery message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: flyteidl.core.IArtifactQuery, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an ArtifactQuery message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ArtifactQuery
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.ArtifactQuery;

            /**
             * Verifies an ArtifactQuery message.
             * @param message Plain object to verify
             * @returns `null` if valid, otherwise the reason why it is not
             */
            public static verify(message: { [k: string]: any }): (string|null);
        }

        /** ResourceType enum. */
        enum ResourceType {
            UNSPECIFIED = 0,
            TASK = 1,
            WORKFLOW = 2,
            LAUNCH_PLAN = 3,
            DATASET = 4
        }

        /** Properties of an Identifier. */
        interface IIdentifier {

            /** Identifier resourceType */
            resourceType?: (flyteidl.core.ResourceType|null);

            /** Identifier project */
            project?: (string|null);

            /** Identifier domain */
            domain?: (string|null);

            /** Identifier name */
            name?: (string|null);

            /** Identifier version */
            version?: (string|null);

            /** Identifier org */
            org?: (string|null);
        }

        /** Represents an Identifier. */
        class Identifier implements IIdentifier {

            /**
             * Constructs a new Identifier.
             * @param [properties] Properties to set
             */
            constructor(properties?: flyteidl.core.IIdentifier);

            /** Identifier resourceType. */
            public resourceType: flyteidl.core.ResourceType;

            /** Identifier project. */
            public project: string;

            /** Identifier domain. */
            public domain: string;

            /** Identifier name. */
            public name: string;

            /** Identifier version. */
            public version: string;

            /** Identifier org. */
            public org: string;

            /**
             * Creates a new Identifier instance using the specified properties.
             * @param [properties] Properties to set
             * @returns Identifier instance
             */
            public static create(properties?: flyteidl.core.IIdentifier): flyteidl.core.Identifier;

            /**
             * Encodes the specified Identifier message. Does not implicitly {@link flyteidl.core.Identifier.verify|verify} messages.
             * @param message Identifier message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: flyteidl.core.IIdentifier, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an Identifier message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns Identifier
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.Identifier;

            /**
             * Verifies an Identifier message.
             * @param message Plain object to verify
             * @returns `null` if valid, otherwise the reason why it is not
             */
            public static verify(message: { [k: string]: any }): (string|null);
        }

        /** Properties of a WorkflowExecutionIdentifier. */
        interface IWorkflowExecutionIdentifier {

            /** WorkflowExecutionIdentifier project */
            project?: (string|null);

            /** WorkflowExecutionIdentifier domain */
            domain?: (string|null);

            /** WorkflowExecutionIdentifier name */
            name?: (string|null);

            /** WorkflowExecutionIdentifier org */
            org?: (string|null);
        }

        /** Represents a WorkflowExecutionIdentifier. */
        class WorkflowExecutionIdentifier implements IWorkflowExecutionIdentifier {

            /**
             * Constructs a new WorkflowExecutionIdentifier.
             * @param [properties] Properties to set
             */
            constructor(properties?: flyteidl.core.IWorkflowExecutionIdentifier);

            /** WorkflowExecutionIdentifier project. */
            public project: string;

            /** WorkflowExecutionIdentifier domain. */
            public domain: string;

            /** WorkflowExecutionIdentifier name. */
            public name: string;

            /** WorkflowExecutionIdentifier org. */
            public org: string;

            /**
             * Creates a new WorkflowExecutionIdentifier instance using the specified properties.
             * @param [properties] Properties to set
             * @returns WorkflowExecutionIdentifier instance
             */
            public static create(properties?: flyteidl.core.IWorkflowExecutionIdentifier): flyteidl.core.WorkflowExecutionIdentifier;

            /**
             * Encodes the specified WorkflowExecutionIdentifier message. Does not implicitly {@link flyteidl.core.WorkflowExecutionIdentifier.verify|verify} messages.
             * @param message WorkflowExecutionIdentifier message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: flyteidl.core.IWorkflowExecutionIdentifier, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a WorkflowExecutionIdentifier message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns WorkflowExecutionIdentifier
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.WorkflowExecutionIdentifier;

            /**
             * Verifies a WorkflowExecutionIdentifier message.
             * @param message Plain object to verify
             * @returns `null` if valid, otherwise the reason why it is not
             */
            public static verify(message: { [k: string]: any }): (string|null);
        }

        /** Properties of a NodeExecutionIdentifier. */
        interface INodeExecutionIdentifier {

            /** NodeExecutionIdentifier nodeId */
            nodeId?: (string|null);

            /** NodeExecutionIdentifier executionId */
            executionId?: (flyteidl.core.IWorkflowExecutionIdentifier|null);
        }

        /** Represents a NodeExecutionIdentifier. */
        class NodeExecutionIdentifier implements INodeExecutionIdentifier {

            /**
             * Constructs a new NodeExecutionIdentifier.
             * @param [properties] Properties to set
             */
            constructor(properties?: flyteidl.core.INodeExecutionIdentifier);

            /** NodeExecutionIdentifier nodeId. */
            public nodeId: string;

            /** NodeExecutionIdentifier executionId. */
            public executionId?: (flyteidl.core.IWorkflowExecutionIdentifier|null);

            /**
             * Creates a new NodeExecutionIdentifier instance using the specified properties.
             * @param [properties] Properties to set
             * @returns NodeExecutionIdentifier instance
             */
            public static create(properties?: flyteidl.core.INodeExecutionIdentifier): flyteidl.core.NodeExecutionIdentifier;

            /**
             * Encodes the specified NodeExecutionIdentifier message. Does not implicitly {@link flyteidl.core.NodeExecutionIdentifier.verify|verify} messages.
             * @param message NodeExecutionIdentifier message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: flyteidl.core.INodeExecutionIdentifier, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a NodeExecutionIdentifier message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns NodeExecutionIdentifier
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.NodeExecutionIdentifier;

            /**
             * Verifies a NodeExecutionIdentifier message.
             * @param message Plain object to verify
             * @returns `null` if valid, otherwise the reason why it is not
             */
            public static verify(message: { [k: string]: any }): (string|null);
        }

        /** Properties of a TaskExecutionIdentifier. */
        interface ITaskExecutionIdentifier {

            /** TaskExecutionIdentifier taskId */
            taskId?: (flyteidl.core.IIdentifier|null);

            /** TaskExecutionIdentifier nodeExecutionId */
            nodeExecutionId?: (flyteidl.core.INodeExecutionIdentifier|null);

            /** TaskExecutionIdentifier retryAttempt */
            retryAttempt?: (number|null);
        }

        /** Represents a TaskExecutionIdentifier. */
        class TaskExecutionIdentifier implements ITaskExecutionIdentifier {

            /**
             * Constructs a new TaskExecutionIdentifier.
             * @param [properties] Properties to set
             */
            constructor(properties?: flyteidl.core.ITaskExecutionIdentifier);

            /** TaskExecutionIdentifier taskId. */
            public taskId?: (flyteidl.core.IIdentifier|null);

            /** TaskExecutionIdentifier nodeExecutionId. */
            public nodeExecutionId?: (flyteidl.core.INodeExecutionIdentifier|null);

            /** TaskExecutionIdentifier retryAttempt. */
            public retryAttempt: number;

            /**
             * Creates a new TaskExecutionIdentifier instance using the specified properties.
             * @param [properties] Properties to set
             * @returns TaskExecutionIdentifier instance
             */
            public static create(properties?: flyteidl.core.ITaskExecutionIdentifier): flyteidl.core.TaskExecutionIdentifier;

            /**
             * Encodes the specified TaskExecutionIdentifier message. Does not implicitly {@link flyteidl.core.TaskExecutionIdentifier.verify|verify} messages.
             * @param message TaskExecutionIdentifier message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: flyteidl.core.ITaskExecutionIdentifier, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a TaskExecutionIdentifier message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns TaskExecutionIdentifier
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.TaskExecutionIdentifier;

            /**
             * Verifies a TaskExecutionIdentifier message.
             * @param message Plain object to verify
             * @returns `null` if valid, otherwise the reason why it is not
             */
            public static verify(message: { [k: string]: any }): (string|null);
        }

        /** Properties of a SignalIdentifier. */
        interface ISignalIdentifier {

            /** SignalIdentifier signalId */
            signalId?: (string|null);

            /** SignalIdentifier executionId */
            executionId?: (flyteidl.core.IWorkflowExecutionIdentifier|null);
        }

        /** Represents a SignalIdentifier. */
        class SignalIdentifier implements ISignalIdentifier {

            /**
             * Constructs a new SignalIdentifier.
             * @param [properties] Properties to set
             */
            constructor(properties?: flyteidl.core.ISignalIdentifier);

            /** SignalIdentifier signalId. */
            public signalId: string;

            /** SignalIdentifier executionId. */
            public executionId?: (flyteidl.core.IWorkflowExecutionIdentifier|null);

            /**
             * Creates a new SignalIdentifier instance using the specified properties.
             * @param [properties] Properties to set
             * @returns SignalIdentifier instance
             */
            public static create(properties?: flyteidl.core.ISignalIdentifier): flyteidl.core.SignalIdentifier;

            /**
             * Encodes the specified SignalIdentifier message. Does not implicitly {@link flyteidl.core.SignalIdentifier.verify|verify} messages.
             * @param message SignalIdentifier message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: flyteidl.core.ISignalIdentifier, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a SignalIdentifier message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns SignalIdentifier
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.SignalIdentifier;

            /**
             * Verifies a SignalIdentifier message.
             * @param message Plain object to verify
             * @returns `null` if valid, otherwise the reason why it is not
             */
            public static verify(message: { [k: string]: any }): (string|null);
        }

        /** CatalogCacheStatus enum. */
        enum CatalogCacheStatus {
            CACHE_DISABLED = 0,
            CACHE_MISS = 1,
            CACHE_HIT = 2,
            CACHE_POPULATED = 3,
            CACHE_LOOKUP_FAILURE = 4,
            CACHE_PUT_FAILURE = 5,
            CACHE_SKIPPED = 6,
            CACHE_EVICTED = 7
        }

        /** Properties of a CatalogArtifactTag. */
        interface ICatalogArtifactTag {

            /** CatalogArtifactTag artifactId */
            artifactId?: (string|null);

            /** CatalogArtifactTag name */
            name?: (string|null);
        }

        /** Represents a CatalogArtifactTag. */
        class CatalogArtifactTag implements ICatalogArtifactTag {

            /**
             * Constructs a new CatalogArtifactTag.
             * @param [properties] Properties to set
             */
            constructor(properties?: flyteidl.core.ICatalogArtifactTag);

            /** CatalogArtifactTag artifactId. */
            public artifactId: string;

            /** CatalogArtifactTag name. */
            public name: string;

            /**
             * Creates a new CatalogArtifactTag instance using the specified properties.
             * @param [properties] Properties to set
             * @returns CatalogArtifactTag instance
             */
            public static create(properties?: flyteidl.core.ICatalogArtifactTag): flyteidl.core.CatalogArtifactTag;

            /**
             * Encodes the specified CatalogArtifactTag message. Does not implicitly {@link flyteidl.core.CatalogArtifactTag.verify|verify} messages.
             * @param message CatalogArtifactTag message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: flyteidl.core.ICatalogArtifactTag, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a CatalogArtifactTag message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns CatalogArtifactTag
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.CatalogArtifactTag;

            /**
             * Verifies a CatalogArtifactTag message.
             * @param message Plain object to verify
             * @returns `null` if valid, otherwise the reason why it is not
             */
            public static verify(message: { [k: string]: any }): (string|null);
        }

        /** Properties of a CatalogMetadata. */
        interface ICatalogMetadata {

            /** CatalogMetadata datasetId */
            datasetId?: (flyteidl.core.IIdentifier|null);

            /** CatalogMetadata artifactTag */
            artifactTag?: (flyteidl.core.ICatalogArtifactTag|null);

            /** CatalogMetadata sourceTaskExecution */
            sourceTaskExecution?: (flyteidl.core.ITaskExecutionIdentifier|null);
        }

        /** Represents a CatalogMetadata. */
        class CatalogMetadata implements ICatalogMetadata {

            /**
             * Constructs a new CatalogMetadata.
             * @param [properties] Properties to set
             */
            constructor(properties?: flyteidl.core.ICatalogMetadata);

            /** CatalogMetadata datasetId. */
            public datasetId?: (flyteidl.core.IIdentifier|null);

            /** CatalogMetadata artifactTag. */
            public artifactTag?: (flyteidl.core.ICatalogArtifactTag|null);

            /** CatalogMetadata sourceTaskExecution. */
            public sourceTaskExecution?: (flyteidl.core.ITaskExecutionIdentifier|null);

            /** CatalogMetadata sourceExecution. */
            public sourceExecution?: "sourceTaskExecution";

            /**
             * Creates a new CatalogMetadata instance using the specified properties.
             * @param [properties] Properties to set
             * @returns CatalogMetadata instance
             */
            public static create(properties?: flyteidl.core.ICatalogMetadata): flyteidl.core.CatalogMetadata;

            /**
             * Encodes the specified CatalogMetadata message. Does not implicitly {@link flyteidl.core.CatalogMetadata.verify|verify} messages.
             * @param message CatalogMetadata message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: flyteidl.core.ICatalogMetadata, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a CatalogMetadata message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns CatalogMetadata
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.CatalogMetadata;

            /**
             * Verifies a CatalogMetadata message.
             * @param message Plain object to verify
             * @returns `null` if valid, otherwise the reason why it is not
             */
            public static verify(message: { [k: string]: any }): (string|null);
        }

        /** Properties of a CatalogReservation. */
        interface ICatalogReservation {
        }

        /** Represents a CatalogReservation. */
        class CatalogReservation implements ICatalogReservation {

            /**
             * Constructs a new CatalogReservation.
             * @param [properties] Properties to set
             */
            constructor(properties?: flyteidl.core.ICatalogReservation);

            /**
             * Creates a new CatalogReservation instance using the specified properties.
             * @param [properties] Properties to set
             * @returns CatalogReservation instance
             */
            public static create(properties?: flyteidl.core.ICatalogReservation): flyteidl.core.CatalogReservation;

            /**
             * Encodes the specified CatalogReservation message. Does not implicitly {@link flyteidl.core.CatalogReservation.verify|verify} messages.
             * @param message CatalogReservation message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: flyteidl.core.ICatalogReservation, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a CatalogReservation message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from