@flyteorg/flyteidl 0.21.25 → 0.22.0

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

@@ -3290,6 +3290,58 @@ export namespace flyteidl {
             public static verify(message: { [k: string]: any }): (string|null);
         }
 
+        /** Properties of a TypeAnnotation. */
+        interface ITypeAnnotation {
+
+            /** TypeAnnotation annotations */
+            annotations?: (google.protobuf.IStruct|null);
+        }
+
+        /** Represents a TypeAnnotation. */
+        class TypeAnnotation implements ITypeAnnotation {
+
+            /**
+             * Constructs a new TypeAnnotation.
+             * @param [properties] Properties to set
+             */
+            constructor(properties?: flyteidl.core.ITypeAnnotation);
+
+            /** TypeAnnotation annotations. */
+            public annotations?: (google.protobuf.IStruct|null);
+
+            /**
+             * Creates a new TypeAnnotation instance using the specified properties.
+             * @param [properties] Properties to set
+             * @returns TypeAnnotation instance
+             */
+            public static create(properties?: flyteidl.core.ITypeAnnotation): flyteidl.core.TypeAnnotation;
+
+            /**
+             * Encodes the specified TypeAnnotation message. Does not implicitly {@link flyteidl.core.TypeAnnotation.verify|verify} messages.
+             * @param message TypeAnnotation message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encode(message: flyteidl.core.ITypeAnnotation, writer?: $protobuf.Writer): $protobuf.Writer;
+
+            /**
+             * Decodes a TypeAnnotation message from the specified reader or buffer.
+             * @param reader Reader or buffer to decode from
+             * @param [length] Message length if known beforehand
+             * @returns TypeAnnotation
+             * @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.TypeAnnotation;
+
+            /**
+             * Verifies a TypeAnnotation 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 LiteralType. */
         interface ILiteralType {
 
@@ -3316,6 +3368,9 @@ export namespace flyteidl {
 
             /** LiteralType metadata */
             metadata?: (google.protobuf.IStruct|null);
+
+            /** LiteralType annotation */
+            annotation?: (flyteidl.core.ITypeAnnotation|null);
         }
 
         /** Represents a LiteralType. */
@@ -3351,6 +3406,9 @@ export namespace flyteidl {
             /** LiteralType metadata. */
             public metadata?: (google.protobuf.IStruct|null);
 
+            /** LiteralType annotation. */
+            public annotation?: (flyteidl.core.ITypeAnnotation|null);
+
             /** LiteralType type. */
             public type?: ("simple"|"schema"|"collectionType"|"mapValueType"|"blob"|"enumType"|"structuredDatasetType");
 

package/gen/pb-js/flyteidl.js

@@ -7856,6 +7856,118 @@ export const flyteidl = $root.flyteidl = (() => {
             return EnumType;
         })();
 
+        core.TypeAnnotation = (function() {
+
+            /**
+             * Properties of a TypeAnnotation.
+             * @memberof flyteidl.core
+             * @interface ITypeAnnotation
+             * @property {google.protobuf.IStruct|null} [annotations] TypeAnnotation annotations
+             */
+
+            /**
+             * Constructs a new TypeAnnotation.
+             * @memberof flyteidl.core
+             * @classdesc Represents a TypeAnnotation.
+             * @implements ITypeAnnotation
+             * @constructor
+             * @param {flyteidl.core.ITypeAnnotation=} [properties] Properties to set
+             */
+            function TypeAnnotation(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]];
+            }
+
+            /**
+             * TypeAnnotation annotations.
+             * @member {google.protobuf.IStruct|null|undefined} annotations
+             * @memberof flyteidl.core.TypeAnnotation
+             * @instance
+             */
+            TypeAnnotation.prototype.annotations = null;
+
+            /**
+             * Creates a new TypeAnnotation instance using the specified properties.
+             * @function create
+             * @memberof flyteidl.core.TypeAnnotation
+             * @static
+             * @param {flyteidl.core.ITypeAnnotation=} [properties] Properties to set
+             * @returns {flyteidl.core.TypeAnnotation} TypeAnnotation instance
+             */
+            TypeAnnotation.create = function create(properties) {
+                return new TypeAnnotation(properties);
+            };
+
+            /**
+             * Encodes the specified TypeAnnotation message. Does not implicitly {@link flyteidl.core.TypeAnnotation.verify|verify} messages.
+             * @function encode
+             * @memberof flyteidl.core.TypeAnnotation
+             * @static
+             * @param {flyteidl.core.ITypeAnnotation} message TypeAnnotation message or plain object to encode
+             * @param {$protobuf.Writer} [writer] Writer to encode to
+             * @returns {$protobuf.Writer} Writer
+             */
+            TypeAnnotation.encode = function encode(message, writer) {
+                if (!writer)
+                    writer = $Writer.create();
+                if (message.annotations != null && message.hasOwnProperty("annotations"))
+                    $root.google.protobuf.Struct.encode(message.annotations, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+                return writer;
+            };
+
+            /**
+             * Decodes a TypeAnnotation message from the specified reader or buffer.
+             * @function decode
+             * @memberof flyteidl.core.TypeAnnotation
+             * @static
+             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+             * @param {number} [length] Message length if known beforehand
+             * @returns {flyteidl.core.TypeAnnotation} TypeAnnotation
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            TypeAnnotation.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.TypeAnnotation();
+                while (reader.pos < end) {
+                    let tag = reader.uint32();
+                    switch (tag >>> 3) {
+                    case 1:
+                        message.annotations = $root.google.protobuf.Struct.decode(reader, reader.uint32());
+                        break;
+                    default:
+                        reader.skipType(tag & 7);
+                        break;
+                    }
+                }
+                return message;
+            };
+
+            /**
+             * Verifies a TypeAnnotation message.
+             * @function verify
+             * @memberof flyteidl.core.TypeAnnotation
+             * @static
+             * @param {Object.<string,*>} message Plain object to verify
+             * @returns {string|null} `null` if valid, otherwise the reason why it is not
+             */
+            TypeAnnotation.verify = function verify(message) {
+                if (typeof message !== "object" || message === null)
+                    return "object expected";
+                if (message.annotations != null && message.hasOwnProperty("annotations")) {
+                    let error = $root.google.protobuf.Struct.verify(message.annotations);
+                    if (error)
+                        return "annotations." + error;
+                }
+                return null;
+            };
+
+            return TypeAnnotation;
+        })();
+
         core.LiteralType = (function() {
 
             /**
@@ -7870,6 +7982,7 @@ export const flyteidl = $root.flyteidl = (() => {
              * @property {flyteidl.core.IEnumType|null} [enumType] LiteralType enumType
              * @property {flyteidl.core.IStructuredDatasetType|null} [structuredDatasetType] LiteralType structuredDatasetType
              * @property {google.protobuf.IStruct|null} [metadata] LiteralType metadata
+             * @property {flyteidl.core.ITypeAnnotation|null} [annotation] LiteralType annotation
              */
 
             /**
@@ -7951,6 +8064,14 @@ export const flyteidl = $root.flyteidl = (() => {
              */
             LiteralType.prototype.metadata = null;
 
+            /**
+             * LiteralType annotation.
+             * @member {flyteidl.core.ITypeAnnotation|null|undefined} annotation
+             * @memberof flyteidl.core.LiteralType
+             * @instance
+             */
+            LiteralType.prototype.annotation = null;
+
             // OneOf field names bound to virtual getters and setters
             let $oneOfFields;
 
@@ -8005,6 +8126,8 @@ export const flyteidl = $root.flyteidl = (() => {
                     $root.flyteidl.core.EnumType.encode(message.enumType, writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim();
                 if (message.structuredDatasetType != null && message.hasOwnProperty("structuredDatasetType"))
                     $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();
                 return writer;
             };
 
@@ -8050,6 +8173,9 @@ export const flyteidl = $root.flyteidl = (() => {
                     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;
                     default:
                         reader.skipType(tag & 7);
                         break;
@@ -8153,6 +8279,11 @@ export const flyteidl = $root.flyteidl = (() => {
                     if (error)
                         return "metadata." + error;
                 }
+                if (message.annotation != null && message.hasOwnProperty("annotation")) {
+                    let error = $root.flyteidl.core.TypeAnnotation.verify(message.annotation);
+                    if (error)
+                        return "annotation." + error;
+                }
                 return null;
             };
 

package/package.json

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

package/protos/docs/core/core.rst

@@ -2383,6 +2383,7 @@ Defines a strong type to allow type checking between interfaces.
    "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"
    "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."
 
 
 
@@ -2500,6 +2501,27 @@ StructuredDatasetType.DatasetColumn
 
 
 
+
+
+.. _ref_flyteidl.core.TypeAnnotation:
+
+TypeAnnotation
+------------------------------------------------------------------
+
+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.
+
+
+
+.. csv-table:: TypeAnnotation type fields
+   :header: "Field", "Type", "Label", "Description"
+   :widths: auto
+
+   "annotations", ":ref:`ref_google.protobuf.Struct`", "", "A arbitrary JSON payload to describe a type."
+
+
+
+
+
  
 
 

package/protos/flyteidl/core/types.proto

@@ -90,6 +90,12 @@ message EnumType {
     repeated string values = 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.
+    google.protobuf.Struct annotations = 1;
+}
+
 // Defines a strong type to allow type checking between interfaces.
 message LiteralType {
     oneof type {
@@ -118,6 +124,10 @@ message LiteralType {
     // 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.
     google.protobuf.Struct metadata = 6;
+
+    // This field contains arbitrary data that might have special semantic
+    // meaning for the client but does not effect internal flyte behavior.
+    TypeAnnotation annotation = 9;
 }
 
 // A reference to an output produced by a node. The type can be retrieved -and validated- from