@burnt-labs/xion-types 0.0.1-test.1762962136

package/types/google/api/field_behavior.ts

@@ -0,0 +1,136 @@
+//@ts-nocheck
+/**
+ * An indicator of the behavior of a given field (for example, that a field
+ * is required in requests, or given as output but ignored as input).
+ * This **does not** change the behavior in protocol buffers itself; it only
+ * denotes the behavior and may affect how API tooling handles the field.
+ * 
+ * Note: This enum **may** receive new values in the future.
+ */
+export enum FieldBehavior {
+  /** FIELD_BEHAVIOR_UNSPECIFIED - Conventional default for enums. Do not use this. */
+  FIELD_BEHAVIOR_UNSPECIFIED = 0,
+  /**
+   * OPTIONAL - Specifically denotes a field as optional.
+   * While all fields in protocol buffers are optional, this may be specified
+   * for emphasis if appropriate.
+   */
+  OPTIONAL = 1,
+  /**
+   * REQUIRED - Denotes a field as required.
+   * This indicates that the field **must** be provided as part of the request,
+   * and failure to do so will cause an error (usually `INVALID_ARGUMENT`).
+   */
+  REQUIRED = 2,
+  /**
+   * OUTPUT_ONLY - Denotes a field as output only.
+   * This indicates that the field is provided in responses, but including the
+   * field in a request does nothing (the server *must* ignore it and
+   * *must not* throw an error as a result of the field's presence).
+   */
+  OUTPUT_ONLY = 3,
+  /**
+   * INPUT_ONLY - Denotes a field as input only.
+   * This indicates that the field is provided in requests, and the
+   * corresponding field is not included in output.
+   */
+  INPUT_ONLY = 4,
+  /**
+   * IMMUTABLE - Denotes a field as immutable.
+   * This indicates that the field may be set once in a request to create a
+   * resource, but may not be changed thereafter.
+   */
+  IMMUTABLE = 5,
+  /**
+   * UNORDERED_LIST - Denotes that a (repeated) field is an unordered list.
+   * This indicates that the service may provide the elements of the list
+   * in any arbitrary  order, rather than the order the user originally
+   * provided. Additionally, the list's order may or may not be stable.
+   */
+  UNORDERED_LIST = 6,
+  /**
+   * NON_EMPTY_DEFAULT - Denotes that this field returns a non-empty default value if not set.
+   * This indicates that if the user provides the empty value in a request,
+   * a non-empty value will be returned. The user will not be aware of what
+   * non-empty value to expect.
+   */
+  NON_EMPTY_DEFAULT = 7,
+  /**
+   * IDENTIFIER - Denotes that the field in a resource (a message annotated with
+   * google.api.resource) is used in the resource name to uniquely identify the
+   * resource. For AIP-compliant APIs, this should only be applied to the
+   * `name` field on the resource.
+   * 
+   * This behavior should not be applied to references to other resources within
+   * the message.
+   * 
+   * The identifier field of resources often have different field behavior
+   * depending on the request it is embedded in (e.g. for Create methods name
+   * is optional and unused, while for Update methods it is required). Instead
+   * of method-specific annotations, only `IDENTIFIER` is required.
+   */
+  IDENTIFIER = 8,
+  UNRECOGNIZED = -1,
+}
+export const FieldBehaviorSDKType = FieldBehavior;
+export const FieldBehaviorAmino = FieldBehavior;
+export function fieldBehaviorFromJSON(object: any): FieldBehavior {
+  switch (object) {
+    case 0:
+    case "FIELD_BEHAVIOR_UNSPECIFIED":
+      return FieldBehavior.FIELD_BEHAVIOR_UNSPECIFIED;
+    case 1:
+    case "OPTIONAL":
+      return FieldBehavior.OPTIONAL;
+    case 2:
+    case "REQUIRED":
+      return FieldBehavior.REQUIRED;
+    case 3:
+    case "OUTPUT_ONLY":
+      return FieldBehavior.OUTPUT_ONLY;
+    case 4:
+    case "INPUT_ONLY":
+      return FieldBehavior.INPUT_ONLY;
+    case 5:
+    case "IMMUTABLE":
+      return FieldBehavior.IMMUTABLE;
+    case 6:
+    case "UNORDERED_LIST":
+      return FieldBehavior.UNORDERED_LIST;
+    case 7:
+    case "NON_EMPTY_DEFAULT":
+      return FieldBehavior.NON_EMPTY_DEFAULT;
+    case 8:
+    case "IDENTIFIER":
+      return FieldBehavior.IDENTIFIER;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return FieldBehavior.UNRECOGNIZED;
+  }
+}
+export function fieldBehaviorToJSON(object: FieldBehavior): string {
+  switch (object) {
+    case FieldBehavior.FIELD_BEHAVIOR_UNSPECIFIED:
+      return "FIELD_BEHAVIOR_UNSPECIFIED";
+    case FieldBehavior.OPTIONAL:
+      return "OPTIONAL";
+    case FieldBehavior.REQUIRED:
+      return "REQUIRED";
+    case FieldBehavior.OUTPUT_ONLY:
+      return "OUTPUT_ONLY";
+    case FieldBehavior.INPUT_ONLY:
+      return "INPUT_ONLY";
+    case FieldBehavior.IMMUTABLE:
+      return "IMMUTABLE";
+    case FieldBehavior.UNORDERED_LIST:
+      return "UNORDERED_LIST";
+    case FieldBehavior.NON_EMPTY_DEFAULT:
+      return "NON_EMPTY_DEFAULT";
+    case FieldBehavior.IDENTIFIER:
+      return "IDENTIFIER";
+    case FieldBehavior.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}

package/types/google/api/field_info.ts

@@ -0,0 +1,319 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../binary";
+/**
+ * The standard format of a field value. The supported formats are all backed
+ * by either an RFC defined by the IETF or a Google-defined AIP.
+ */
+export enum FieldInfo_Format {
+  /** FORMAT_UNSPECIFIED - Default, unspecified value. */
+  FORMAT_UNSPECIFIED = 0,
+  /**
+   * UUID4 - Universally Unique Identifier, version 4, value as defined by
+   * https://datatracker.ietf.org/doc/html/rfc4122. The value may be
+   * normalized to entirely lowercase letters. For example, the value
+   * `F47AC10B-58CC-0372-8567-0E02B2C3D479` would be normalized to
+   * `f47ac10b-58cc-0372-8567-0e02b2c3d479`.
+   */
+  UUID4 = 1,
+  /**
+   * IPV4 - Internet Protocol v4 value as defined by [RFC
+   * 791](https://datatracker.ietf.org/doc/html/rfc791). The value may be
+   * condensed, with leading zeros in each octet stripped. For example,
+   * `001.022.233.040` would be condensed to `1.22.233.40`.
+   */
+  IPV4 = 2,
+  /**
+   * IPV6 - Internet Protocol v6 value as defined by [RFC
+   * 2460](https://datatracker.ietf.org/doc/html/rfc2460). The value may be
+   * normalized to entirely lowercase letters with zeros compressed, following
+   * [RFC 5952](https://datatracker.ietf.org/doc/html/rfc5952). For example,
+   * the value `2001:0DB8:0::0` would be normalized to `2001:db8::`.
+   */
+  IPV6 = 3,
+  /**
+   * IPV4_OR_IPV6 - An IP address in either v4 or v6 format as described by the individual
+   * values defined herein. See the comments on the IPV4 and IPV6 types for
+   * allowed normalizations of each.
+   */
+  IPV4_OR_IPV6 = 4,
+  UNRECOGNIZED = -1,
+}
+export const FieldInfo_FormatSDKType = FieldInfo_Format;
+export const FieldInfo_FormatAmino = FieldInfo_Format;
+export function fieldInfo_FormatFromJSON(object: any): FieldInfo_Format {
+  switch (object) {
+    case 0:
+    case "FORMAT_UNSPECIFIED":
+      return FieldInfo_Format.FORMAT_UNSPECIFIED;
+    case 1:
+    case "UUID4":
+      return FieldInfo_Format.UUID4;
+    case 2:
+    case "IPV4":
+      return FieldInfo_Format.IPV4;
+    case 3:
+    case "IPV6":
+      return FieldInfo_Format.IPV6;
+    case 4:
+    case "IPV4_OR_IPV6":
+      return FieldInfo_Format.IPV4_OR_IPV6;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return FieldInfo_Format.UNRECOGNIZED;
+  }
+}
+export function fieldInfo_FormatToJSON(object: FieldInfo_Format): string {
+  switch (object) {
+    case FieldInfo_Format.FORMAT_UNSPECIFIED:
+      return "FORMAT_UNSPECIFIED";
+    case FieldInfo_Format.UUID4:
+      return "UUID4";
+    case FieldInfo_Format.IPV4:
+      return "IPV4";
+    case FieldInfo_Format.IPV6:
+      return "IPV6";
+    case FieldInfo_Format.IPV4_OR_IPV6:
+      return "IPV4_OR_IPV6";
+    case FieldInfo_Format.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+/** Rich semantic information of an API field beyond basic typing. */
+export interface FieldInfo {
+  /**
+   * The standard format of a field value. This does not explicitly configure
+   * any API consumer, just documents the API's format for the field it is
+   * applied to.
+   */
+  format: FieldInfo_Format;
+  /**
+   * The type(s) that the annotated, generic field may represent.
+   * 
+   * Currently, this must only be used on fields of type `google.protobuf.Any`.
+   * Supporting other generic types may be considered in the future.
+   */
+  referencedTypes: TypeReference[];
+}
+export interface FieldInfoProtoMsg {
+  typeUrl: "/google.api.FieldInfo";
+  value: Uint8Array;
+}
+/**
+ * Rich semantic information of an API field beyond basic typing.
+ * @name FieldInfoAmino
+ * @package google.api
+ * @see proto type: google.api.FieldInfo
+ */
+export interface FieldInfoAmino {
+  /**
+   * The standard format of a field value. This does not explicitly configure
+   * any API consumer, just documents the API's format for the field it is
+   * applied to.
+   */
+  format?: FieldInfo_Format;
+  /**
+   * The type(s) that the annotated, generic field may represent.
+   * 
+   * Currently, this must only be used on fields of type `google.protobuf.Any`.
+   * Supporting other generic types may be considered in the future.
+   */
+  referenced_types?: TypeReferenceAmino[];
+}
+export interface FieldInfoAminoMsg {
+  type: "/google.api.FieldInfo";
+  value: FieldInfoAmino;
+}
+/** Rich semantic information of an API field beyond basic typing. */
+export interface FieldInfoSDKType {
+  format: FieldInfo_Format;
+  referenced_types: TypeReferenceSDKType[];
+}
+/** A reference to a message type, for use in [FieldInfo][google.api.FieldInfo]. */
+export interface TypeReference {
+  /**
+   * The name of the type that the annotated, generic field may represent.
+   * If the type is in the same protobuf package, the value can be the simple
+   * message name e.g., `"MyMessage"`. Otherwise, the value must be the
+   * fully-qualified message name e.g., `"google.library.v1.Book"`.
+   * 
+   * If the type(s) are unknown to the service (e.g. the field accepts generic
+   * user input), use the wildcard `"*"` to denote this behavior.
+   * 
+   * See [AIP-202](https://google.aip.dev/202#type-references) for more details.
+   */
+  typeName: string;
+}
+export interface TypeReferenceProtoMsg {
+  typeUrl: "/google.api.TypeReference";
+  value: Uint8Array;
+}
+/**
+ * A reference to a message type, for use in [FieldInfo][google.api.FieldInfo].
+ * @name TypeReferenceAmino
+ * @package google.api
+ * @see proto type: google.api.TypeReference
+ */
+export interface TypeReferenceAmino {
+  /**
+   * The name of the type that the annotated, generic field may represent.
+   * If the type is in the same protobuf package, the value can be the simple
+   * message name e.g., `"MyMessage"`. Otherwise, the value must be the
+   * fully-qualified message name e.g., `"google.library.v1.Book"`.
+   * 
+   * If the type(s) are unknown to the service (e.g. the field accepts generic
+   * user input), use the wildcard `"*"` to denote this behavior.
+   * 
+   * See [AIP-202](https://google.aip.dev/202#type-references) for more details.
+   */
+  type_name?: string;
+}
+export interface TypeReferenceAminoMsg {
+  type: "/google.api.TypeReference";
+  value: TypeReferenceAmino;
+}
+/** A reference to a message type, for use in [FieldInfo][google.api.FieldInfo]. */
+export interface TypeReferenceSDKType {
+  type_name: string;
+}
+function createBaseFieldInfo(): FieldInfo {
+  return {
+    format: 0,
+    referencedTypes: []
+  };
+}
+export const FieldInfo = {
+  typeUrl: "/google.api.FieldInfo",
+  encode(message: FieldInfo, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.format !== 0) {
+      writer.uint32(8).int32(message.format);
+    }
+    for (const v of message.referencedTypes) {
+      TypeReference.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): FieldInfo {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFieldInfo();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.format = reader.int32() as any;
+          break;
+        case 2:
+          message.referencedTypes.push(TypeReference.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<FieldInfo>): FieldInfo {
+    const message = createBaseFieldInfo();
+    message.format = object.format ?? 0;
+    message.referencedTypes = object.referencedTypes?.map(e => TypeReference.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: FieldInfoAmino): FieldInfo {
+    const message = createBaseFieldInfo();
+    if (object.format !== undefined && object.format !== null) {
+      message.format = object.format;
+    }
+    message.referencedTypes = object.referenced_types?.map(e => TypeReference.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: FieldInfo): FieldInfoAmino {
+    const obj: any = {};
+    obj.format = message.format === 0 ? undefined : message.format;
+    if (message.referencedTypes) {
+      obj.referenced_types = message.referencedTypes.map(e => e ? TypeReference.toAmino(e) : undefined);
+    } else {
+      obj.referenced_types = message.referencedTypes;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: FieldInfoAminoMsg): FieldInfo {
+    return FieldInfo.fromAmino(object.value);
+  },
+  fromProtoMsg(message: FieldInfoProtoMsg): FieldInfo {
+    return FieldInfo.decode(message.value);
+  },
+  toProto(message: FieldInfo): Uint8Array {
+    return FieldInfo.encode(message).finish();
+  },
+  toProtoMsg(message: FieldInfo): FieldInfoProtoMsg {
+    return {
+      typeUrl: "/google.api.FieldInfo",
+      value: FieldInfo.encode(message).finish()
+    };
+  }
+};
+function createBaseTypeReference(): TypeReference {
+  return {
+    typeName: ""
+  };
+}
+export const TypeReference = {
+  typeUrl: "/google.api.TypeReference",
+  encode(message: TypeReference, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.typeName !== "") {
+      writer.uint32(10).string(message.typeName);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): TypeReference {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTypeReference();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.typeName = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<TypeReference>): TypeReference {
+    const message = createBaseTypeReference();
+    message.typeName = object.typeName ?? "";
+    return message;
+  },
+  fromAmino(object: TypeReferenceAmino): TypeReference {
+    const message = createBaseTypeReference();
+    if (object.type_name !== undefined && object.type_name !== null) {
+      message.typeName = object.type_name;
+    }
+    return message;
+  },
+  toAmino(message: TypeReference): TypeReferenceAmino {
+    const obj: any = {};
+    obj.type_name = message.typeName === "" ? undefined : message.typeName;
+    return obj;
+  },
+  fromAminoMsg(object: TypeReferenceAminoMsg): TypeReference {
+    return TypeReference.fromAmino(object.value);
+  },
+  fromProtoMsg(message: TypeReferenceProtoMsg): TypeReference {
+    return TypeReference.decode(message.value);
+  },
+  toProto(message: TypeReference): Uint8Array {
+    return TypeReference.encode(message).finish();
+  },
+  toProtoMsg(message: TypeReference): TypeReferenceProtoMsg {
+    return {
+      typeUrl: "/google.api.TypeReference",
+      value: TypeReference.encode(message).finish()
+    };
+  }
+};