@flyteorg/flyteidl 0.23.1 → 0.24.0

package/gen/pb-js/flyteidl.d.ts

@@ -2177,6 +2177,64 @@ export namespace flyteidl {
             public static verify(message: { [k: string]: any }): (string|null);
         }
 
+        /** Properties of an Union. */
+        interface IUnion {
+
+            /** Union value */
+            value?: (flyteidl.core.ILiteral|null);
+
+            /** Union type */
+            type?: (flyteidl.core.ILiteralType|null);
+        }
+
+        /** Represents an Union. */
+        class Union implements IUnion {
+
+            /**
+             * Constructs a new Union.
+             * @param [properties] Properties to set
+             */
+            constructor(properties?: flyteidl.core.IUnion);
+
+            /** Union value. */
+            public value?: (flyteidl.core.ILiteral|null);
+
+            /** Union type. */
+            public type?: (flyteidl.core.ILiteralType|null);
+
+            /**
+             * Creates a new Union instance using the specified properties.
+             * @param [properties] Properties to set
+             * @returns Union instance
+             */
+            public static create(properties?: flyteidl.core.IUnion): flyteidl.core.Union;
+
+            /**
+             * Encodes the specified Union message. Does not implicitly {@link flyteidl.core.Union.verify|verify} messages.
+             * @param message Union message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encode(message: flyteidl.core.IUnion, writer?: $protobuf.Writer): $protobuf.Writer;
+
+            /**
+             * Decodes an Union message from the specified reader or buffer.
+             * @param reader Reader or buffer to decode from
+             * @param [length] Message length if known beforehand
+             * @returns Union
+             * @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.Union;
+
+            /**
+             * Verifies an Union 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 StructuredDatasetMetadata. */
         interface IStructuredDatasetMetadata {
 
@@ -2313,6 +2371,9 @@ export namespace flyteidl {
 
             /** Scalar structuredDataset */
             structuredDataset?: (flyteidl.core.IStructuredDataset|null);
+
+            /** Scalar union */
+            union?: (flyteidl.core.IUnion|null);
         }
 
         /** Represents a Scalar. */
@@ -2348,8 +2409,11 @@ export namespace flyteidl {
             /** Scalar structuredDataset. */
             public structuredDataset?: (flyteidl.core.IStructuredDataset|null);
 
+            /** Scalar union. */
+            public union?: (flyteidl.core.IUnion|null);
+
             /** Scalar value. */
-            public value?: ("primitive"|"blob"|"binary"|"schema"|"noneType"|"error"|"generic"|"structuredDataset");
+            public value?: ("primitive"|"blob"|"binary"|"schema"|"noneType"|"error"|"generic"|"structuredDataset"|"union");
 
             /**
              * Creates a new Scalar instance using the specified properties.
@@ -2665,6 +2729,58 @@ export namespace flyteidl {
             public static verify(message: { [k: string]: any }): (string|null);
         }
 
+        /** Properties of an UnionInfo. */
+        interface IUnionInfo {
+
+            /** UnionInfo targetType */
+            targetType?: (flyteidl.core.ILiteralType|null);
+        }
+
+        /** Represents an UnionInfo. */
+        class UnionInfo implements IUnionInfo {
+
+            /**
+             * Constructs a new UnionInfo.
+             * @param [properties] Properties to set
+             */
+            constructor(properties?: flyteidl.core.IUnionInfo);
+
+            /** UnionInfo targetType. */
+            public targetType?: (flyteidl.core.ILiteralType|null);
+
+            /**
+             * Creates a new UnionInfo instance using the specified properties.
+             * @param [properties] Properties to set
+             * @returns UnionInfo instance
+             */
+            public static create(properties?: flyteidl.core.IUnionInfo): flyteidl.core.UnionInfo;
+
+            /**
+             * Encodes the specified UnionInfo message. Does not implicitly {@link flyteidl.core.UnionInfo.verify|verify} messages.
+             * @param message UnionInfo message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encode(message: flyteidl.core.IUnionInfo, writer?: $protobuf.Writer): $protobuf.Writer;
+
+            /**
+             * Decodes an UnionInfo message from the specified reader or buffer.
+             * @param reader Reader or buffer to decode from
+             * @param [length] Message length if known beforehand
+             * @returns UnionInfo
+             * @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.UnionInfo;
+
+            /**
+             * Verifies an UnionInfo 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 BindingData. */
         interface IBindingData {
 
@@ -2679,6 +2795,9 @@ export namespace flyteidl {
 
             /** BindingData map */
             map?: (flyteidl.core.IBindingDataMap|null);
+
+            /** BindingData union */
+            union?: (flyteidl.core.IUnionInfo|null);
         }
 
         /** Represents a BindingData. */
@@ -2702,6 +2821,9 @@ export namespace flyteidl {
             /** BindingData map. */
             public map?: (flyteidl.core.IBindingDataMap|null);
 
+            /** BindingData union. */
+            public union?: (flyteidl.core.IUnionInfo|null);
+
             /** BindingData value. */
             public value?: ("scalar"|"collection"|"promise"|"map");
 
@@ -3296,6 +3418,110 @@ export namespace flyteidl {
             public static verify(message: { [k: string]: any }): (string|null);
         }
 
+        /** Properties of an UnionType. */
+        interface IUnionType {
+
+            /** UnionType variants */
+            variants?: (flyteidl.core.ILiteralType[]|null);
+        }
+
+        /** Represents an UnionType. */
+        class UnionType implements IUnionType {
+
+            /**
+             * Constructs a new UnionType.
+             * @param [properties] Properties to set
+             */
+            constructor(properties?: flyteidl.core.IUnionType);
+
+            /** UnionType variants. */
+            public variants: flyteidl.core.ILiteralType[];
+
+            /**
+             * Creates a new UnionType instance using the specified properties.
+             * @param [properties] Properties to set
+             * @returns UnionType instance
+             */
+            public static create(properties?: flyteidl.core.IUnionType): flyteidl.core.UnionType;
+
+            /**
+             * Encodes the specified UnionType message. Does not implicitly {@link flyteidl.core.UnionType.verify|verify} messages.
+             * @param message UnionType message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encode(message: flyteidl.core.IUnionType, writer?: $protobuf.Writer): $protobuf.Writer;
+
+            /**
+             * Decodes an UnionType message from the specified reader or buffer.
+             * @param reader Reader or buffer to decode from
+             * @param [length] Message length if known beforehand
+             * @returns UnionType
+             * @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.UnionType;
+
+            /**
+             * Verifies an UnionType 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 TypeStructure. */
+        interface ITypeStructure {
+
+            /** TypeStructure tag */
+            tag?: (string|null);
+        }
+
+        /** Represents a TypeStructure. */
+        class TypeStructure implements ITypeStructure {
+
+            /**
+             * Constructs a new TypeStructure.
+             * @param [properties] Properties to set
+             */
+            constructor(properties?: flyteidl.core.ITypeStructure);
+
+            /** TypeStructure tag. */
+            public tag: string;
+
+            /**
+             * Creates a new TypeStructure instance using the specified properties.
+             * @param [properties] Properties to set
+             * @returns TypeStructure instance
+             */
+            public static create(properties?: flyteidl.core.ITypeStructure): flyteidl.core.TypeStructure;
+
+            /**
+             * Encodes the specified TypeStructure message. Does not implicitly {@link flyteidl.core.TypeStructure.verify|verify} messages.
+             * @param message TypeStructure message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encode(message: flyteidl.core.ITypeStructure, writer?: $protobuf.Writer): $protobuf.Writer;
+
+            /**
+             * Decodes a TypeStructure message from the specified reader or buffer.
+             * @param reader Reader or buffer to decode from
+             * @param [length] Message length if known beforehand
+             * @returns TypeStructure
+             * @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.TypeStructure;
+
+            /**
+             * Verifies a TypeStructure 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 TypeAnnotation. */
         interface ITypeAnnotation {
 
@@ -3372,11 +3598,17 @@ export namespace flyteidl {
             /** LiteralType structuredDatasetType */
             structuredDatasetType?: (flyteidl.core.IStructuredDatasetType|null);
 
+            /** LiteralType unionType */
+            unionType?: (flyteidl.core.IUnionType|null);
+
             /** LiteralType metadata */
             metadata?: (google.protobuf.IStruct|null);
 
             /** LiteralType annotation */
             annotation?: (flyteidl.core.ITypeAnnotation|null);
+
+            /** LiteralType structure */
+            structure?: (flyteidl.core.ITypeStructure|null);
         }
 
         /** Represents a LiteralType. */
@@ -3409,14 +3641,20 @@ export namespace flyteidl {
             /** LiteralType structuredDatasetType. */
             public structuredDatasetType?: (flyteidl.core.IStructuredDatasetType|null);
 
+            /** LiteralType unionType. */
+            public unionType?: (flyteidl.core.IUnionType|null);
+
             /** LiteralType metadata. */
             public metadata?: (google.protobuf.IStruct|null);
 
             /** LiteralType annotation. */
             public annotation?: (flyteidl.core.ITypeAnnotation|null);
 
+            /** LiteralType structure. */
+            public structure?: (flyteidl.core.ITypeStructure|null);
+
             /** LiteralType type. */
-            public type?: ("simple"|"schema"|"collectionType"|"mapValueType"|"blob"|"enumType"|"structuredDatasetType");
+            public type?: ("simple"|"schema"|"collectionType"|"mapValueType"|"blob"|"enumType"|"structuredDatasetType"|"unionType");
 
             /**
              * Creates a new LiteralType instance using the specified properties.

package/gen/pb-js/flyteidl.js

@@ -5207,6 +5207,137 @@ export const flyteidl = $root.flyteidl = (() => {
             return Schema;
         })();
 
+        core.Union = (function() {
+
+            /**
+             * Properties of an Union.
+             * @memberof flyteidl.core
+             * @interface IUnion
+             * @property {flyteidl.core.ILiteral|null} [value] Union value
+             * @property {flyteidl.core.ILiteralType|null} [type] Union type
+             */
+
+            /**
+             * Constructs a new Union.
+             * @memberof flyteidl.core
+             * @classdesc Represents an Union.
+             * @implements IUnion
+             * @constructor
+             * @param {flyteidl.core.IUnion=} [properties] Properties to set
+             */
+            function Union(properties) {
+                if (properties)
+                    for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                        if (properties[keys[i]] != null)
+                            this[keys[i]] = properties[keys[i]];
+            }
+
+            /**
+             * Union value.
+             * @member {flyteidl.core.ILiteral|null|undefined} value
+             * @memberof flyteidl.core.Union
+             * @instance
+             */
+            Union.prototype.value = null;
+
+            /**
+             * Union type.
+             * @member {flyteidl.core.ILiteralType|null|undefined} type
+             * @memberof flyteidl.core.Union
+             * @instance
+             */
+            Union.prototype.type = null;
+
+            /**
+             * Creates a new Union instance using the specified properties.
+             * @function create
+             * @memberof flyteidl.core.Union
+             * @static
+             * @param {flyteidl.core.IUnion=} [properties] Properties to set
+             * @returns {flyteidl.core.Union} Union instance
+             */
+            Union.create = function create(properties) {
+                return new Union(properties);
+            };
+
+            /**
+             * Encodes the specified Union message. Does not implicitly {@link flyteidl.core.Union.verify|verify} messages.
+             * @function encode
+             * @memberof flyteidl.core.Union
+             * @static
+             * @param {flyteidl.core.IUnion} message Union message or plain object to encode
+             * @param {$protobuf.Writer} [writer] Writer to encode to
+             * @returns {$protobuf.Writer} Writer
+             */
+            Union.encode = function encode(message, writer) {
+                if (!writer)
+                    writer = $Writer.create();
+                if (message.value != null && message.hasOwnProperty("value"))
+                    $root.flyteidl.core.Literal.encode(message.value, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+                if (message.type != null && message.hasOwnProperty("type"))
+                    $root.flyteidl.core.LiteralType.encode(message.type, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+                return writer;
+            };
+
+            /**
+             * Decodes an Union message from the specified reader or buffer.
+             * @function decode
+             * @memberof flyteidl.core.Union
+             * @static
+             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+             * @param {number} [length] Message length if known beforehand
+             * @returns {flyteidl.core.Union} Union
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            Union.decode = function decode(reader, length) {
+                if (!(reader instanceof $Reader))
+                    reader = $Reader.create(reader);
+                let end = length === undefined ? reader.len : reader.pos + length, message = new $root.flyteidl.core.Union();
+                while (reader.pos < end) {
+                    let tag = reader.uint32();
+                    switch (tag >>> 3) {
+                    case 1:
+                        message.value = $root.flyteidl.core.Literal.decode(reader, reader.uint32());
+                        break;
+                    case 2:
+                        message.type = $root.flyteidl.core.LiteralType.decode(reader, reader.uint32());
+                        break;
+                    default:
+                        reader.skipType(tag & 7);
+                        break;
+                    }
+                }
+                return message;
+            };
+
+            /**
+             * Verifies an Union message.
+             * @function verify
+             * @memberof flyteidl.core.Union
+             * @static
+             * @param {Object.<string,*>} message Plain object to verify
+             * @returns {string|null} `null` if valid, otherwise the reason why it is not
+             */
+            Union.verify = function verify(message) {
+                if (typeof message !== "object" || message === null)
+                    return "object expected";
+                if (message.value != null && message.hasOwnProperty("value")) {
+                    let error = $root.flyteidl.core.Literal.verify(message.value);
+                    if (error)
+                        return "value." + error;
+                }
+                if (message.type != null && message.hasOwnProperty("type")) {
+                    let error = $root.flyteidl.core.LiteralType.verify(message.type);
+                    if (error)
+                        return "type." + error;
+                }
+                return null;
+            };
+
+            return Union;
+        })();
+
         core.StructuredDatasetMetadata = (function() {
 
             /**
@@ -5462,6 +5593,7 @@ export const flyteidl = $root.flyteidl = (() => {
              * @property {flyteidl.core.IError|null} [error] Scalar error
              * @property {google.protobuf.IStruct|null} [generic] Scalar generic
              * @property {flyteidl.core.IStructuredDataset|null} [structuredDataset] Scalar structuredDataset
+             * @property {flyteidl.core.IUnion|null} [union] Scalar union
              */
 
             /**
@@ -5543,17 +5675,25 @@ export const flyteidl = $root.flyteidl = (() => {
              */
             Scalar.prototype.structuredDataset = null;
 
+            /**
+             * Scalar union.
+             * @member {flyteidl.core.IUnion|null|undefined} union
+             * @memberof flyteidl.core.Scalar
+             * @instance
+             */
+            Scalar.prototype.union = null;
+
             // OneOf field names bound to virtual getters and setters
             let $oneOfFields;
 
             /**
              * Scalar value.
-             * @member {"primitive"|"blob"|"binary"|"schema"|"noneType"|"error"|"generic"|"structuredDataset"|undefined} value
+             * @member {"primitive"|"blob"|"binary"|"schema"|"noneType"|"error"|"generic"|"structuredDataset"|"union"|undefined} value
              * @memberof flyteidl.core.Scalar
              * @instance
              */
             Object.defineProperty(Scalar.prototype, "value", {
-                get: $util.oneOfGetter($oneOfFields = ["primitive", "blob", "binary", "schema", "noneType", "error", "generic", "structuredDataset"]),
+                get: $util.oneOfGetter($oneOfFields = ["primitive", "blob", "binary", "schema", "noneType", "error", "generic", "structuredDataset", "union"]),
                 set: $util.oneOfSetter($oneOfFields)
             });
 
@@ -5597,6 +5737,8 @@ export const flyteidl = $root.flyteidl = (() => {
                     $root.google.protobuf.Struct.encode(message.generic, writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim();
                 if (message.structuredDataset != null && message.hasOwnProperty("structuredDataset"))
                     $root.flyteidl.core.StructuredDataset.encode(message.structuredDataset, writer.uint32(/* id 8, wireType 2 =*/66).fork()).ldelim();
+                if (message.union != null && message.hasOwnProperty("union"))
+                    $root.flyteidl.core.Union.encode(message.union, writer.uint32(/* id 9, wireType 2 =*/74).fork()).ldelim();
                 return writer;
             };
 
@@ -5642,6 +5784,9 @@ export const flyteidl = $root.flyteidl = (() => {
                     case 8:
                         message.structuredDataset = $root.flyteidl.core.StructuredDataset.decode(reader, reader.uint32());
                         break;
+                    case 9:
+                        message.union = $root.flyteidl.core.Union.decode(reader, reader.uint32());
+                        break;
                     default:
                         reader.skipType(tag & 7);
                         break;
@@ -5740,6 +5885,16 @@ export const flyteidl = $root.flyteidl = (() => {
                             return "structuredDataset." + error;
                     }
                 }
+                if (message.union != null && message.hasOwnProperty("union")) {
+                    if (properties.value === 1)
+                        return "value: multiple values";
+                    properties.value = 1;
+                    {
+                        let error = $root.flyteidl.core.Union.verify(message.union);
+                        if (error)
+                            return "union." + error;
+                    }
+                }
                 return null;
             };
 
@@ -6433,6 +6588,118 @@ export const flyteidl = $root.flyteidl = (() => {
             return BindingDataMap;
         })();
 
+        core.UnionInfo = (function() {
+
+            /**
+             * Properties of an UnionInfo.
+             * @memberof flyteidl.core
+             * @interface IUnionInfo
+             * @property {flyteidl.core.ILiteralType|null} [targetType] UnionInfo targetType
+             */
+
+            /**
+             * Constructs a new UnionInfo.
+             * @memberof flyteidl.core
+             * @classdesc Represents an UnionInfo.
+             * @implements IUnionInfo
+             * @constructor
+             * @param {flyteidl.core.IUnionInfo=} [properties] Properties to set
+             */
+            function UnionInfo(properties) {
+                if (properties)
+                    for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                        if (properties[keys[i]] != null)
+                            this[keys[i]] = properties[keys[i]];
+            }
+
+            /**
+             * UnionInfo targetType.
+             * @member {flyteidl.core.ILiteralType|null|undefined} targetType
+             * @memberof flyteidl.core.UnionInfo
+             * @instance
+             */
+            UnionInfo.prototype.targetType = null;
+
+            /**
+             * Creates a new UnionInfo instance using the specified properties.
+             * @function create
+             * @memberof flyteidl.core.UnionInfo
+             * @static
+             * @param {flyteidl.core.IUnionInfo=} [properties] Properties to set
+             * @returns {flyteidl.core.UnionInfo} UnionInfo instance
+             */
+            UnionInfo.create = function create(properties) {
+                return new UnionInfo(properties);
+            };
+
+            /**
+             * Encodes the specified UnionInfo message. Does not implicitly {@link flyteidl.core.UnionInfo.verify|verify} messages.
+             * @function encode
+             * @memberof flyteidl.core.UnionInfo
+             * @static
+             * @param {flyteidl.core.IUnionInfo} message UnionInfo message or plain object to encode
+             * @param {$protobuf.Writer} [writer] Writer to encode to
+             * @returns {$protobuf.Writer} Writer
+             */
+            UnionInfo.encode = function encode(message, writer) {
+                if (!writer)
+                    writer = $Writer.create();
+                if (message.targetType != null && message.hasOwnProperty("targetType"))
+                    $root.flyteidl.core.LiteralType.encode(message.targetType, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+                return writer;
+            };
+
+            /**
+             * Decodes an UnionInfo message from the specified reader or buffer.
+             * @function decode
+             * @memberof flyteidl.core.UnionInfo
+             * @static
+             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+             * @param {number} [length] Message length if known beforehand
+             * @returns {flyteidl.core.UnionInfo} UnionInfo
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            UnionInfo.decode = function decode(reader, length) {
+                if (!(reader instanceof $Reader))
+                    reader = $Reader.create(reader);
+                let end = length === undefined ? reader.len : reader.pos + length, message = new $root.flyteidl.core.UnionInfo();
+                while (reader.pos < end) {
+                    let tag = reader.uint32();
+                    switch (tag >>> 3) {
+                    case 1:
+                        message.targetType = $root.flyteidl.core.LiteralType.decode(reader, reader.uint32());
+                        break;
+                    default:
+                        reader.skipType(tag & 7);
+                        break;
+                    }
+                }
+                return message;
+            };
+
+            /**
+             * Verifies an UnionInfo message.
+             * @function verify
+             * @memberof flyteidl.core.UnionInfo
+             * @static
+             * @param {Object.<string,*>} message Plain object to verify
+             * @returns {string|null} `null` if valid, otherwise the reason why it is not
+             */
+            UnionInfo.verify = function verify(message) {
+                if (typeof message !== "object" || message === null)
+                    return "object expected";
+                if (message.targetType != null && message.hasOwnProperty("targetType")) {
+                    let error = $root.flyteidl.core.LiteralType.verify(message.targetType);
+                    if (error)
+                        return "targetType." + error;
+                }
+                return null;
+            };
+
+            return UnionInfo;
+        })();
+
         core.BindingData = (function() {
 
             /**
@@ -6443,6 +6710,7 @@ export const flyteidl = $root.flyteidl = (() => {
              * @property {flyteidl.core.IBindingDataCollection|null} [collection] BindingData collection
              * @property {flyteidl.core.IOutputReference|null} [promise] BindingData promise
              * @property {flyteidl.core.IBindingDataMap|null} [map] BindingData map
+             * @property {flyteidl.core.IUnionInfo|null} [union] BindingData union
              */
 
             /**
@@ -6492,6 +6760,14 @@ export const flyteidl = $root.flyteidl = (() => {
              */
             BindingData.prototype.map = null;
 
+            /**
+             * BindingData union.
+             * @member {flyteidl.core.IUnionInfo|null|undefined} union
+             * @memberof flyteidl.core.BindingData
+             * @instance
+             */
+            BindingData.prototype.union = null;
+
             // OneOf field names bound to virtual getters and setters
             let $oneOfFields;
 
@@ -6538,6 +6814,8 @@ export const flyteidl = $root.flyteidl = (() => {
                     $root.flyteidl.core.OutputReference.encode(message.promise, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();
                 if (message.map != null && message.hasOwnProperty("map"))
                     $root.flyteidl.core.BindingDataMap.encode(message.map, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();
+                if (message.union != null && message.hasOwnProperty("union"))
+                    $root.flyteidl.core.UnionInfo.encode(message.union, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();
                 return writer;
             };
 
@@ -6571,6 +6849,9 @@ export const flyteidl = $root.flyteidl = (() => {
                     case 4:
                         message.map = $root.flyteidl.core.BindingDataMap.decode(reader, reader.uint32());
                         break;
+                    case 5:
+                        message.union = $root.flyteidl.core.UnionInfo.decode(reader, reader.uint32());
+                        break;
                     default:
                         reader.skipType(tag & 7);
                         break;
@@ -6629,6 +6910,11 @@ export const flyteidl = $root.flyteidl = (() => {
                             return "map." + error;
                     }
                 }
+                if (message.union != null && message.hasOwnProperty("union")) {
+                    let error = $root.flyteidl.core.UnionInfo.verify(message.union);
+                    if (error)
+                        return "union." + error;
+                }
                 return null;
             };
 
@@ -7873,6 +8159,236 @@ export const flyteidl = $root.flyteidl = (() => {
             return EnumType;
         })();
 
+        core.UnionType = (function() {
+
+            /**
+             * Properties of an UnionType.
+             * @memberof flyteidl.core
+             * @interface IUnionType
+             * @property {Array.<flyteidl.core.ILiteralType>|null} [variants] UnionType variants
+             */
+
+            /**
+             * Constructs a new UnionType.
+             * @memberof flyteidl.core
+             * @classdesc Represents an UnionType.
+             * @implements IUnionType
+             * @constructor
+             * @param {flyteidl.core.IUnionType=} [properties] Properties to set
+             */
+            function UnionType(properties) {
+                this.variants = [];
+                if (properties)
+                    for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                        if (properties[keys[i]] != null)
+                            this[keys[i]] = properties[keys[i]];
+            }
+
+            /**
+             * UnionType variants.
+             * @member {Array.<flyteidl.core.ILiteralType>} variants
+             * @memberof flyteidl.core.UnionType
+             * @instance
+             */
+            UnionType.prototype.variants = $util.emptyArray;
+
+            /**
+             * Creates a new UnionType instance using the specified properties.
+             * @function create
+             * @memberof flyteidl.core.UnionType
+             * @static
+             * @param {flyteidl.core.IUnionType=} [properties] Properties to set
+             * @returns {flyteidl.core.UnionType} UnionType instance
+             */
+            UnionType.create = function create(properties) {
+                return new UnionType(properties);
+            };
+
+            /**
+             * Encodes the specified UnionType message. Does not implicitly {@link flyteidl.core.UnionType.verify|verify} messages.
+             * @function encode
+             * @memberof flyteidl.core.UnionType
+             * @static
+             * @param {flyteidl.core.IUnionType} message UnionType message or plain object to encode
+             * @param {$protobuf.Writer} [writer] Writer to encode to
+             * @returns {$protobuf.Writer} Writer
+             */
+            UnionType.encode = function encode(message, writer) {
+                if (!writer)
+                    writer = $Writer.create();
+                if (message.variants != null && message.variants.length)
+                    for (let i = 0; i < message.variants.length; ++i)
+                        $root.flyteidl.core.LiteralType.encode(message.variants[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+                return writer;
+            };
+
+            /**
+             * Decodes an UnionType message from the specified reader or buffer.
+             * @function decode
+             * @memberof flyteidl.core.UnionType
+             * @static
+             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+             * @param {number} [length] Message length if known beforehand
+             * @returns {flyteidl.core.UnionType} UnionType
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            UnionType.decode = function decode(reader, length) {
+                if (!(reader instanceof $Reader))
+                    reader = $Reader.create(reader);
+                let end = length === undefined ? reader.len : reader.pos + length, message = new $root.flyteidl.core.UnionType();
+                while (reader.pos < end) {
+                    let tag = reader.uint32();
+                    switch (tag >>> 3) {
+                    case 1:
+                        if (!(message.variants && message.variants.length))
+                            message.variants = [];
+                        message.variants.push($root.flyteidl.core.LiteralType.decode(reader, reader.uint32()));
+                        break;
+                    default:
+                        reader.skipType(tag & 7);
+                        break;
+                    }
+                }
+                return message;
+            };
+
+            /**
+             * Verifies an UnionType message.
+             * @function verify
+             * @memberof flyteidl.core.UnionType
+             * @static
+             * @param {Object.<string,*>} message Plain object to verify
+             * @returns {string|null} `null` if valid, otherwise the reason why it is not
+             */
+            UnionType.verify = function verify(message) {
+                if (typeof message !== "object" || message === null)
+                    return "object expected";
+                if (message.variants != null && message.hasOwnProperty("variants")) {
+                    if (!Array.isArray(message.variants))
+                        return "variants: array expected";
+                    for (let i = 0; i < message.variants.length; ++i) {
+                        let error = $root.flyteidl.core.LiteralType.verify(message.variants[i]);
+                        if (error)
+                            return "variants." + error;
+                    }
+                }
+                return null;
+            };
+
+            return UnionType;
+        })();
+
+        core.TypeStructure = (function() {
+
+            /**
+             * Properties of a TypeStructure.
+             * @memberof flyteidl.core
+             * @interface ITypeStructure
+             * @property {string|null} [tag] TypeStructure tag
+             */
+
+            /**
+             * Constructs a new TypeStructure.
+             * @memberof flyteidl.core
+             * @classdesc Represents a TypeStructure.
+             * @implements ITypeStructure
+             * @constructor
+             * @param {flyteidl.core.ITypeStructure=} [properties] Properties to set
+             */
+            function TypeStructure(properties) {
+                if (properties)
+                    for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                        if (properties[keys[i]] != null)
+                            this[keys[i]] = properties[keys[i]];
+            }
+
+            /**
+             * TypeStructure tag.
+             * @member {string} tag
+             * @memberof flyteidl.core.TypeStructure
+             * @instance
+             */
+            TypeStructure.prototype.tag = "";
+
+            /**
+             * Creates a new TypeStructure instance using the specified properties.
+             * @function create
+             * @memberof flyteidl.core.TypeStructure
+             * @static
+             * @param {flyteidl.core.ITypeStructure=} [properties] Properties to set
+             * @returns {flyteidl.core.TypeStructure} TypeStructure instance
+             */
+            TypeStructure.create = function create(properties) {
+                return new TypeStructure(properties);
+            };
+
+            /**
+             * Encodes the specified TypeStructure message. Does not implicitly {@link flyteidl.core.TypeStructure.verify|verify} messages.
+             * @function encode
+             * @memberof flyteidl.core.TypeStructure
+             * @static
+             * @param {flyteidl.core.ITypeStructure} message TypeStructure message or plain object to encode
+             * @param {$protobuf.Writer} [writer] Writer to encode to
+             * @returns {$protobuf.Writer} Writer
+             */
+            TypeStructure.encode = function encode(message, writer) {
+                if (!writer)
+                    writer = $Writer.create();
+                if (message.tag != null && message.hasOwnProperty("tag"))
+                    writer.uint32(/* id 1, wireType 2 =*/10).string(message.tag);
+                return writer;
+            };
+
+            /**
+             * Decodes a TypeStructure message from the specified reader or buffer.
+             * @function decode
+             * @memberof flyteidl.core.TypeStructure
+             * @static
+             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+             * @param {number} [length] Message length if known beforehand
+             * @returns {flyteidl.core.TypeStructure} TypeStructure
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            TypeStructure.decode = function decode(reader, length) {
+                if (!(reader instanceof $Reader))
+                    reader = $Reader.create(reader);
+                let end = length === undefined ? reader.len : reader.pos + length, message = new $root.flyteidl.core.TypeStructure();
+                while (reader.pos < end) {
+                    let tag = reader.uint32();
+                    switch (tag >>> 3) {
+                    case 1:
+                        message.tag = reader.string();
+                        break;
+                    default:
+                        reader.skipType(tag & 7);
+                        break;
+                    }
+                }
+                return message;
+            };
+
+            /**
+             * Verifies a TypeStructure message.
+             * @function verify
+             * @memberof flyteidl.core.TypeStructure
+             * @static
+             * @param {Object.<string,*>} message Plain object to verify
+             * @returns {string|null} `null` if valid, otherwise the reason why it is not
+             */
+            TypeStructure.verify = function verify(message) {
+                if (typeof message !== "object" || message === null)
+                    return "object expected";
+                if (message.tag != null && message.hasOwnProperty("tag"))
+                    if (!$util.isString(message.tag))
+                        return "tag: string expected";
+                return null;
+            };
+
+            return TypeStructure;
+        })();
+
         core.TypeAnnotation = (function() {
 
             /**
@@ -7998,8 +8514,10 @@ export const flyteidl = $root.flyteidl = (() => {
              * @property {flyteidl.core.IBlobType|null} [blob] LiteralType blob
              * @property {flyteidl.core.IEnumType|null} [enumType] LiteralType enumType
              * @property {flyteidl.core.IStructuredDatasetType|null} [structuredDatasetType] LiteralType structuredDatasetType
+             * @property {flyteidl.core.IUnionType|null} [unionType] LiteralType unionType
              * @property {google.protobuf.IStruct|null} [metadata] LiteralType metadata
              * @property {flyteidl.core.ITypeAnnotation|null} [annotation] LiteralType annotation
+             * @property {flyteidl.core.ITypeStructure|null} [structure] LiteralType structure
              */
 
             /**
@@ -8073,6 +8591,14 @@ export const flyteidl = $root.flyteidl = (() => {
              */
             LiteralType.prototype.structuredDatasetType = null;
 
+            /**
+             * LiteralType unionType.
+             * @member {flyteidl.core.IUnionType|null|undefined} unionType
+             * @memberof flyteidl.core.LiteralType
+             * @instance
+             */
+            LiteralType.prototype.unionType = null;
+
             /**
              * LiteralType metadata.
              * @member {google.protobuf.IStruct|null|undefined} metadata
@@ -8089,17 +8615,25 @@ export const flyteidl = $root.flyteidl = (() => {
              */
             LiteralType.prototype.annotation = null;
 
+            /**
+             * LiteralType structure.
+             * @member {flyteidl.core.ITypeStructure|null|undefined} structure
+             * @memberof flyteidl.core.LiteralType
+             * @instance
+             */
+            LiteralType.prototype.structure = null;
+
             // OneOf field names bound to virtual getters and setters
             let $oneOfFields;
 
             /**
              * LiteralType type.
-             * @member {"simple"|"schema"|"collectionType"|"mapValueType"|"blob"|"enumType"|"structuredDatasetType"|undefined} type
+             * @member {"simple"|"schema"|"collectionType"|"mapValueType"|"blob"|"enumType"|"structuredDatasetType"|"unionType"|undefined} type
              * @memberof flyteidl.core.LiteralType
              * @instance
              */
             Object.defineProperty(LiteralType.prototype, "type", {
-                get: $util.oneOfGetter($oneOfFields = ["simple", "schema", "collectionType", "mapValueType", "blob", "enumType", "structuredDatasetType"]),
+                get: $util.oneOfGetter($oneOfFields = ["simple", "schema", "collectionType", "mapValueType", "blob", "enumType", "structuredDatasetType", "unionType"]),
                 set: $util.oneOfSetter($oneOfFields)
             });
 
@@ -8145,6 +8679,10 @@ export const flyteidl = $root.flyteidl = (() => {
                     $root.flyteidl.core.StructuredDatasetType.encode(message.structuredDatasetType, writer.uint32(/* id 8, wireType 2 =*/66).fork()).ldelim();
                 if (message.annotation != null && message.hasOwnProperty("annotation"))
                     $root.flyteidl.core.TypeAnnotation.encode(message.annotation, writer.uint32(/* id 9, wireType 2 =*/74).fork()).ldelim();
+                if (message.unionType != null && message.hasOwnProperty("unionType"))
+                    $root.flyteidl.core.UnionType.encode(message.unionType, writer.uint32(/* id 10, wireType 2 =*/82).fork()).ldelim();
+                if (message.structure != null && message.hasOwnProperty("structure"))
+                    $root.flyteidl.core.TypeStructure.encode(message.structure, writer.uint32(/* id 11, wireType 2 =*/90).fork()).ldelim();
                 return writer;
             };
 
@@ -8187,12 +8725,18 @@ export const flyteidl = $root.flyteidl = (() => {
                     case 8:
                         message.structuredDatasetType = $root.flyteidl.core.StructuredDatasetType.decode(reader, reader.uint32());
                         break;
+                    case 10:
+                        message.unionType = $root.flyteidl.core.UnionType.decode(reader, reader.uint32());
+                        break;
                     case 6:
                         message.metadata = $root.google.protobuf.Struct.decode(reader, reader.uint32());
                         break;
                     case 9:
                         message.annotation = $root.flyteidl.core.TypeAnnotation.decode(reader, reader.uint32());
                         break;
+                    case 11:
+                        message.structure = $root.flyteidl.core.TypeStructure.decode(reader, reader.uint32());
+                        break;
                     default:
                         reader.skipType(tag & 7);
                         break;
@@ -8291,6 +8835,16 @@ export const flyteidl = $root.flyteidl = (() => {
                             return "structuredDatasetType." + error;
                     }
                 }
+                if (message.unionType != null && message.hasOwnProperty("unionType")) {
+                    if (properties.type === 1)
+                        return "type: multiple values";
+                    properties.type = 1;
+                    {
+                        let error = $root.flyteidl.core.UnionType.verify(message.unionType);
+                        if (error)
+                            return "unionType." + error;
+                    }
+                }
                 if (message.metadata != null && message.hasOwnProperty("metadata")) {
                     let error = $root.google.protobuf.Struct.verify(message.metadata);
                     if (error)
@@ -8301,6 +8855,11 @@ export const flyteidl = $root.flyteidl = (() => {
                     if (error)
                         return "annotation." + error;
                 }
+                if (message.structure != null && message.hasOwnProperty("structure")) {
+                    let error = $root.flyteidl.core.TypeStructure.verify(message.structure);
+                    if (error)
+                        return "structure." + error;
+                }
                 return null;
             };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flyteorg/flyteidl",
-  "version": "0.23.1",
+  "version": "0.24.0",
   "description": "Compiled protocol buffers and gRPC service clients/servers for Flyte IDLs",
   "repository": {
     "type": "git",

package/protos/docs/admin/admin.rst

@@ -1053,6 +1053,7 @@ of an execution as it progresses across phase changes.
    "auth_role", ":ref:`ref_flyteidl.admin.AuthRole`", "", "**Deprecated.** Optional: auth override to apply this execution."
    "quality_of_service", ":ref:`ref_flyteidl.core.QualityOfService`", "", "Indicates the runtime priority of the execution."
    "max_parallelism", ":ref:`ref_int32`", "", "Controls the maximum number of task nodes that can be run in parallel for the entire workflow. This is useful to achieve fairness. Note: MapTasks are regarded as one unit, and parallelism/concurrency of MapTasks is independent from this."
+   "raw_output_data_config", ":ref:`ref_flyteidl.admin.RawOutputDataConfig`", "", "User setting to configure where to store offloaded data (i.e. Blobs, structured datasets, query data, etc.). This should be a prefix like s3://my-bucket/my-data"
 
 
 

package/protos/docs/core/core.rst

@@ -1216,6 +1216,7 @@ Specifies either a simple value or a reference to another output.
    "collection", ":ref:`ref_flyteidl.core.BindingDataCollection`", "", "A collection of binding data. This allows nesting of binding data to any number of levels."
    "promise", ":ref:`ref_flyteidl.core.OutputReference`", "", "References an output promised by another node."
    "map", ":ref:`ref_flyteidl.core.BindingDataMap`", "", "A map of bindings. The key is always a string."
+   "union", ":ref:`ref_flyteidl.core.UnionInfo`", "", ""
 
 
 
@@ -1509,6 +1510,7 @@ Scalar
    "error", ":ref:`ref_flyteidl.core.Error`", "", ""
    "generic", ":ref:`ref_google.protobuf.Struct`", "", ""
    "structured_dataset", ":ref:`ref_flyteidl.core.StructuredDataset`", "", ""
+   "union", ":ref:`ref_flyteidl.core.Union`", "", ""
 
 
 
@@ -1581,6 +1583,49 @@ StructuredDatasetMetadata
 
 
 
+.. _ref_flyteidl.core.Union:
+
+Union
+------------------------------------------------------------------
+
+The runtime representation of a tagged union value. See `UnionType` for more details.
+
+
+
+.. csv-table:: Union type fields
+   :header: "Field", "Type", "Label", "Description"
+   :widths: auto
+
+   "value", ":ref:`ref_flyteidl.core.Literal`", "", ""
+   "type", ":ref:`ref_flyteidl.core.LiteralType`", "", ""
+
+
+
+
+
+
+
+.. _ref_flyteidl.core.UnionInfo:
+
+UnionInfo
+------------------------------------------------------------------
+
+
+
+
+
+.. csv-table:: UnionInfo type fields
+   :header: "Field", "Type", "Label", "Description"
+   :widths: auto
+
+   "targetType", ":ref:`ref_flyteidl.core.LiteralType`", "", ""
+
+
+
+
+
+
+
 .. _ref_flyteidl.core.Void:
 
 Void
@@ -2383,8 +2428,10 @@ Defines a strong type to allow type checking between interfaces.
    "blob", ":ref:`ref_flyteidl.core.BlobType`", "", "A blob might have specialized implementation details depending on associated metadata."
    "enum_type", ":ref:`ref_flyteidl.core.EnumType`", "", "Defines an enum with pre-defined string values."
    "structured_dataset_type", ":ref:`ref_flyteidl.core.StructuredDatasetType`", "", "Generalized schema support"
+   "union_type", ":ref:`ref_flyteidl.core.UnionType`", "", "Defines an union type with pre-defined LiteralTypes."
    "metadata", ":ref:`ref_google.protobuf.Struct`", "", "This field contains type metadata that is descriptive of the type, but is NOT considered in type-checking. This might be used by consumers to identify special behavior or display extended information for the type."
    "annotation", ":ref:`ref_flyteidl.core.TypeAnnotation`", "", "This field contains arbitrary data that might have special semantic meaning for the client but does not effect internal flyte behavior."
+   "structure", ":ref:`ref_flyteidl.core.TypeStructure`", "", "Hints to improve type matching."
 
 
 
@@ -2523,6 +2570,62 @@ TypeAnnotation encapsulates registration time information about a type. This can
 
 
 
+
+
+.. _ref_flyteidl.core.TypeStructure:
+
+TypeStructure
+------------------------------------------------------------------
+
+Hints to improve type matching
+e.g. allows distinguishing output from custom type transformers
+even if the underlying IDL serialization matches.
+
+
+
+.. csv-table:: TypeStructure type fields
+   :header: "Field", "Type", "Label", "Description"
+   :widths: auto
+
+   "tag", ":ref:`ref_string`", "", "Must exactly match for types to be castable"
+
+
+
+
+
+
+
+.. _ref_flyteidl.core.UnionType:
+
+UnionType
+------------------------------------------------------------------
+
+Defines a tagged union type, also known as a variant (and formally as the sum type).
+
+A sum type S is defined by a sequence of types (A, B, C, ...), each tagged by a string tag
+A value of type S is constructed from a value of any of the variant types. The specific choice of type is recorded by
+storing the varaint's tag with the literal value and can be examined in runtime.
+
+Type S is typically written as
+S := Apple A | Banana B | Cantaloupe C | ...
+
+Notably, a nullable (optional) type is a sum type between some type X and the singleton type representing a null-value:
+Optional X := X | Null
+
+See also: https://en.wikipedia.org/wiki/Tagged_union
+
+
+
+.. csv-table:: UnionType type fields
+   :header: "Field", "Type", "Label", "Description"
+   :widths: auto
+
+   "variants", ":ref:`ref_flyteidl.core.LiteralType`", "repeated", "Predefined set of variants in union."
+
+
+
+
+
  
 
 

package/protos/flyteidl/core/literals.proto

@@ -52,6 +52,12 @@ message Schema {
     SchemaType type = 3;
 }
 
+// The runtime representation of a tagged union value. See `UnionType` for more details.
+message Union {
+    Literal value = 1;
+    LiteralType type = 2;
+}
+
 message StructuredDatasetMetadata {
     // Bundle the type information along with the literal.
     // This is here because StructuredDatasets can often be more defined at run time than at compile time.
@@ -81,6 +87,7 @@ message Scalar {
         Error error = 6;
         google.protobuf.Struct generic = 7;
         StructuredDataset structured_dataset = 8;
+        Union union = 9;
     }
 }
 
@@ -123,6 +130,10 @@ message BindingDataMap {
     map<string, BindingData> bindings = 1;
 }
 
+message UnionInfo {
+  LiteralType targetType = 1;
+}
+
 // Specifies either a simple value or a reference to another output.
 message BindingData {
     oneof value {
@@ -139,6 +150,8 @@ message BindingData {
         // A map of bindings. The key is always a string.
         BindingDataMap map = 4;
     }
+
+    UnionInfo union = 5;
 }
 
 // An input/output binding of a variable to either static value or a node output.

package/protos/flyteidl/core/types.proto

@@ -90,6 +90,32 @@ message EnumType {
     repeated string values = 1;
 }
 
+// Defines a tagged union type, also known as a variant (and formally as the sum type).
+//
+// A sum type S is defined by a sequence of types (A, B, C, ...), each tagged by a string tag
+// A value of type S is constructed from a value of any of the variant types. The specific choice of type is recorded by
+// storing the varaint's tag with the literal value and can be examined in runtime.
+//
+// Type S is typically written as
+// S := Apple A | Banana B | Cantaloupe C | ...
+//
+// Notably, a nullable (optional) type is a sum type between some type X and the singleton type representing a null-value:
+// Optional X := X | Null
+//
+// See also: https://en.wikipedia.org/wiki/Tagged_union
+message UnionType {
+    // Predefined set of variants in union.
+    repeated LiteralType variants = 1;
+}
+
+// Hints to improve type matching
+// e.g. allows distinguishing output from custom type transformers
+// even if the underlying IDL serialization matches.
+message TypeStructure {
+    // Must exactly match for types to be castable
+    string tag = 1;
+}
+
 // TypeAnnotation encapsulates registration time information about a type. This can be used for various control-plane operations. TypeAnnotation will not be available at runtime when a task runs.
 message TypeAnnotation {
     // A arbitrary JSON payload to describe a type.
@@ -119,6 +145,9 @@ message LiteralType {
 
         // Generalized schema support
         StructuredDatasetType structured_dataset_type = 8;
+
+        // Defines an union type with pre-defined LiteralTypes.
+        UnionType union_type = 10;
     }
 
     // This field contains type metadata that is descriptive of the type, but is NOT considered in type-checking.  This might be used by
@@ -128,6 +157,9 @@ message LiteralType {
     // This field contains arbitrary data that might have special semantic
     // meaning for the client but does not effect internal flyte behavior.
     TypeAnnotation annotation = 9;
+
+    // Hints to improve type matching.
+    TypeStructure structure = 11;
 }
 
 // A reference to an output produced by a node. The type can be retrieved -and validated- from