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

package/types/google/api/httpbody.ts

@@ -0,0 +1,270 @@
+//@ts-nocheck
+import { Any, AnyAmino, AnySDKType } from "../protobuf/any";
+import { BinaryReader, BinaryWriter } from "../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../helpers";
+/**
+ * Message that represents an arbitrary HTTP body. It should only be used for
+ * payload formats that can't be represented as JSON, such as raw binary or
+ * an HTML page.
+ * 
+ * 
+ * This message can be used both in streaming and non-streaming API methods in
+ * the request as well as the response.
+ * 
+ * It can be used as a top-level request field, which is convenient if one
+ * wants to extract parameters from either the URL or HTTP template into the
+ * request fields and also want access to the raw HTTP body.
+ * 
+ * Example:
+ * 
+ *     message GetResourceRequest {
+ *       // A unique request id.
+ *       string request_id = 1;
+ * 
+ *       // The raw HTTP body is bound to this field.
+ *       google.api.HttpBody http_body = 2;
+ * 
+ *     }
+ * 
+ *     service ResourceService {
+ *       rpc GetResource(GetResourceRequest)
+ *         returns (google.api.HttpBody);
+ *       rpc UpdateResource(google.api.HttpBody)
+ *         returns (google.protobuf.Empty);
+ * 
+ *     }
+ * 
+ * Example with streaming methods:
+ * 
+ *     service CaldavService {
+ *       rpc GetCalendar(stream google.api.HttpBody)
+ *         returns (stream google.api.HttpBody);
+ *       rpc UpdateCalendar(stream google.api.HttpBody)
+ *         returns (stream google.api.HttpBody);
+ * 
+ *     }
+ * 
+ * Use of this type only changes how the request and response bodies are
+ * handled, all other features will continue to work unchanged.
+ */
+export interface HttpBody {
+  /** The HTTP Content-Type header value specifying the content type of the body. */
+  contentType: string;
+  /** The HTTP request/response body as raw binary. */
+  data: Uint8Array;
+  /**
+   * Application specific response metadata. Must be set in the first response
+   * for streaming APIs.
+   */
+  extensions: Any[];
+}
+export interface HttpBodyProtoMsg {
+  typeUrl: "/google.api.HttpBody";
+  value: Uint8Array;
+}
+/**
+ * Message that represents an arbitrary HTTP body. It should only be used for
+ * payload formats that can't be represented as JSON, such as raw binary or
+ * an HTML page.
+ * 
+ * 
+ * This message can be used both in streaming and non-streaming API methods in
+ * the request as well as the response.
+ * 
+ * It can be used as a top-level request field, which is convenient if one
+ * wants to extract parameters from either the URL or HTTP template into the
+ * request fields and also want access to the raw HTTP body.
+ * 
+ * Example:
+ * 
+ *     message GetResourceRequest {
+ *       // A unique request id.
+ *       string request_id = 1;
+ * 
+ *       // The raw HTTP body is bound to this field.
+ *       google.api.HttpBody http_body = 2;
+ * 
+ *     }
+ * 
+ *     service ResourceService {
+ *       rpc GetResource(GetResourceRequest)
+ *         returns (google.api.HttpBody);
+ *       rpc UpdateResource(google.api.HttpBody)
+ *         returns (google.protobuf.Empty);
+ * 
+ *     }
+ * 
+ * Example with streaming methods:
+ * 
+ *     service CaldavService {
+ *       rpc GetCalendar(stream google.api.HttpBody)
+ *         returns (stream google.api.HttpBody);
+ *       rpc UpdateCalendar(stream google.api.HttpBody)
+ *         returns (stream google.api.HttpBody);
+ * 
+ *     }
+ * 
+ * Use of this type only changes how the request and response bodies are
+ * handled, all other features will continue to work unchanged.
+ * @name HttpBodyAmino
+ * @package google.api
+ * @see proto type: google.api.HttpBody
+ */
+export interface HttpBodyAmino {
+  /**
+   * The HTTP Content-Type header value specifying the content type of the body.
+   */
+  content_type?: string;
+  /**
+   * The HTTP request/response body as raw binary.
+   */
+  data?: string;
+  /**
+   * Application specific response metadata. Must be set in the first response
+   * for streaming APIs.
+   */
+  extensions?: AnyAmino[];
+}
+export interface HttpBodyAminoMsg {
+  type: "/google.api.HttpBody";
+  value: HttpBodyAmino;
+}
+/**
+ * Message that represents an arbitrary HTTP body. It should only be used for
+ * payload formats that can't be represented as JSON, such as raw binary or
+ * an HTML page.
+ * 
+ * 
+ * This message can be used both in streaming and non-streaming API methods in
+ * the request as well as the response.
+ * 
+ * It can be used as a top-level request field, which is convenient if one
+ * wants to extract parameters from either the URL or HTTP template into the
+ * request fields and also want access to the raw HTTP body.
+ * 
+ * Example:
+ * 
+ *     message GetResourceRequest {
+ *       // A unique request id.
+ *       string request_id = 1;
+ * 
+ *       // The raw HTTP body is bound to this field.
+ *       google.api.HttpBody http_body = 2;
+ * 
+ *     }
+ * 
+ *     service ResourceService {
+ *       rpc GetResource(GetResourceRequest)
+ *         returns (google.api.HttpBody);
+ *       rpc UpdateResource(google.api.HttpBody)
+ *         returns (google.protobuf.Empty);
+ * 
+ *     }
+ * 
+ * Example with streaming methods:
+ * 
+ *     service CaldavService {
+ *       rpc GetCalendar(stream google.api.HttpBody)
+ *         returns (stream google.api.HttpBody);
+ *       rpc UpdateCalendar(stream google.api.HttpBody)
+ *         returns (stream google.api.HttpBody);
+ * 
+ *     }
+ * 
+ * Use of this type only changes how the request and response bodies are
+ * handled, all other features will continue to work unchanged.
+ */
+export interface HttpBodySDKType {
+  content_type: string;
+  data: Uint8Array;
+  extensions: AnySDKType[];
+}
+function createBaseHttpBody(): HttpBody {
+  return {
+    contentType: "",
+    data: new Uint8Array(),
+    extensions: []
+  };
+}
+export const HttpBody = {
+  typeUrl: "/google.api.HttpBody",
+  encode(message: HttpBody, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.contentType !== "") {
+      writer.uint32(10).string(message.contentType);
+    }
+    if (message.data.length !== 0) {
+      writer.uint32(18).bytes(message.data);
+    }
+    for (const v of message.extensions) {
+      Any.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): HttpBody {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseHttpBody();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.contentType = reader.string();
+          break;
+        case 2:
+          message.data = reader.bytes();
+          break;
+        case 3:
+          message.extensions.push(Any.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<HttpBody>): HttpBody {
+    const message = createBaseHttpBody();
+    message.contentType = object.contentType ?? "";
+    message.data = object.data ?? new Uint8Array();
+    message.extensions = object.extensions?.map(e => Any.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: HttpBodyAmino): HttpBody {
+    const message = createBaseHttpBody();
+    if (object.content_type !== undefined && object.content_type !== null) {
+      message.contentType = object.content_type;
+    }
+    if (object.data !== undefined && object.data !== null) {
+      message.data = bytesFromBase64(object.data);
+    }
+    message.extensions = object.extensions?.map(e => Any.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: HttpBody): HttpBodyAmino {
+    const obj: any = {};
+    obj.content_type = message.contentType === "" ? undefined : message.contentType;
+    obj.data = message.data ? base64FromBytes(message.data) : undefined;
+    if (message.extensions) {
+      obj.extensions = message.extensions.map(e => e ? Any.toAmino(e) : undefined);
+    } else {
+      obj.extensions = message.extensions;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: HttpBodyAminoMsg): HttpBody {
+    return HttpBody.fromAmino(object.value);
+  },
+  fromProtoMsg(message: HttpBodyProtoMsg): HttpBody {
+    return HttpBody.decode(message.value);
+  },
+  toProto(message: HttpBody): Uint8Array {
+    return HttpBody.encode(message).finish();
+  },
+  toProtoMsg(message: HttpBody): HttpBodyProtoMsg {
+    return {
+      typeUrl: "/google.api.HttpBody",
+      value: HttpBody.encode(message).finish()
+    };
+  }
+};

package/types/google/api/label.ts

@@ -0,0 +1,174 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../binary";
+/** Value types that can be used as label values. */
+export enum LabelDescriptor_ValueType {
+  /** STRING - A variable-length string. This is the default. */
+  STRING = 0,
+  /** BOOL - Boolean; true or false. */
+  BOOL = 1,
+  /** INT64 - A 64-bit signed integer. */
+  INT64 = 2,
+  UNRECOGNIZED = -1,
+}
+export const LabelDescriptor_ValueTypeSDKType = LabelDescriptor_ValueType;
+export const LabelDescriptor_ValueTypeAmino = LabelDescriptor_ValueType;
+export function labelDescriptor_ValueTypeFromJSON(object: any): LabelDescriptor_ValueType {
+  switch (object) {
+    case 0:
+    case "STRING":
+      return LabelDescriptor_ValueType.STRING;
+    case 1:
+    case "BOOL":
+      return LabelDescriptor_ValueType.BOOL;
+    case 2:
+    case "INT64":
+      return LabelDescriptor_ValueType.INT64;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return LabelDescriptor_ValueType.UNRECOGNIZED;
+  }
+}
+export function labelDescriptor_ValueTypeToJSON(object: LabelDescriptor_ValueType): string {
+  switch (object) {
+    case LabelDescriptor_ValueType.STRING:
+      return "STRING";
+    case LabelDescriptor_ValueType.BOOL:
+      return "BOOL";
+    case LabelDescriptor_ValueType.INT64:
+      return "INT64";
+    case LabelDescriptor_ValueType.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+/** A description of a label. */
+export interface LabelDescriptor {
+  /** The label key. */
+  key: string;
+  /** The type of data that can be assigned to the label. */
+  valueType: LabelDescriptor_ValueType;
+  /** A human-readable description for the label. */
+  description: string;
+}
+export interface LabelDescriptorProtoMsg {
+  typeUrl: "/google.api.LabelDescriptor";
+  value: Uint8Array;
+}
+/**
+ * A description of a label.
+ * @name LabelDescriptorAmino
+ * @package google.api
+ * @see proto type: google.api.LabelDescriptor
+ */
+export interface LabelDescriptorAmino {
+  /**
+   * The label key.
+   */
+  key?: string;
+  /**
+   * The type of data that can be assigned to the label.
+   */
+  value_type?: LabelDescriptor_ValueType;
+  /**
+   * A human-readable description for the label.
+   */
+  description?: string;
+}
+export interface LabelDescriptorAminoMsg {
+  type: "/google.api.LabelDescriptor";
+  value: LabelDescriptorAmino;
+}
+/** A description of a label. */
+export interface LabelDescriptorSDKType {
+  key: string;
+  value_type: LabelDescriptor_ValueType;
+  description: string;
+}
+function createBaseLabelDescriptor(): LabelDescriptor {
+  return {
+    key: "",
+    valueType: 0,
+    description: ""
+  };
+}
+export const LabelDescriptor = {
+  typeUrl: "/google.api.LabelDescriptor",
+  encode(message: LabelDescriptor, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.valueType !== 0) {
+      writer.uint32(16).int32(message.valueType);
+    }
+    if (message.description !== "") {
+      writer.uint32(26).string(message.description);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): LabelDescriptor {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseLabelDescriptor();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.key = reader.string();
+          break;
+        case 2:
+          message.valueType = reader.int32() as any;
+          break;
+        case 3:
+          message.description = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<LabelDescriptor>): LabelDescriptor {
+    const message = createBaseLabelDescriptor();
+    message.key = object.key ?? "";
+    message.valueType = object.valueType ?? 0;
+    message.description = object.description ?? "";
+    return message;
+  },
+  fromAmino(object: LabelDescriptorAmino): LabelDescriptor {
+    const message = createBaseLabelDescriptor();
+    if (object.key !== undefined && object.key !== null) {
+      message.key = object.key;
+    }
+    if (object.value_type !== undefined && object.value_type !== null) {
+      message.valueType = object.value_type;
+    }
+    if (object.description !== undefined && object.description !== null) {
+      message.description = object.description;
+    }
+    return message;
+  },
+  toAmino(message: LabelDescriptor): LabelDescriptorAmino {
+    const obj: any = {};
+    obj.key = message.key === "" ? undefined : message.key;
+    obj.value_type = message.valueType === 0 ? undefined : message.valueType;
+    obj.description = message.description === "" ? undefined : message.description;
+    return obj;
+  },
+  fromAminoMsg(object: LabelDescriptorAminoMsg): LabelDescriptor {
+    return LabelDescriptor.fromAmino(object.value);
+  },
+  fromProtoMsg(message: LabelDescriptorProtoMsg): LabelDescriptor {
+    return LabelDescriptor.decode(message.value);
+  },
+  toProto(message: LabelDescriptor): Uint8Array {
+    return LabelDescriptor.encode(message).finish();
+  },
+  toProtoMsg(message: LabelDescriptor): LabelDescriptorProtoMsg {
+    return {
+      typeUrl: "/google.api.LabelDescriptor",
+      value: LabelDescriptor.encode(message).finish()
+    };
+  }
+};

package/types/google/api/launch_stage.ts

@@ -0,0 +1,112 @@
+//@ts-nocheck
+/**
+ * The launch stage as defined by [Google Cloud Platform
+ * Launch Stages](https://cloud.google.com/terms/launch-stages).
+ */
+export enum LaunchStage {
+  /** LAUNCH_STAGE_UNSPECIFIED - Do not use this default value. */
+  LAUNCH_STAGE_UNSPECIFIED = 0,
+  /** UNIMPLEMENTED - The feature is not yet implemented. Users can not use it. */
+  UNIMPLEMENTED = 6,
+  /** PRELAUNCH - Prelaunch features are hidden from users and are only visible internally. */
+  PRELAUNCH = 7,
+  /**
+   * EARLY_ACCESS - Early Access features are limited to a closed group of testers. To use
+   * these features, you must sign up in advance and sign a Trusted Tester
+   * agreement (which includes confidentiality provisions). These features may
+   * be unstable, changed in backward-incompatible ways, and are not
+   * guaranteed to be released.
+   */
+  EARLY_ACCESS = 1,
+  /**
+   * ALPHA - Alpha is a limited availability test for releases before they are cleared
+   * for widespread use. By Alpha, all significant design issues are resolved
+   * and we are in the process of verifying functionality. Alpha customers
+   * need to apply for access, agree to applicable terms, and have their
+   * projects allowlisted. Alpha releases don't have to be feature complete,
+   * no SLAs are provided, and there are no technical support obligations, but
+   * they will be far enough along that customers can actually use them in
+   * test environments or for limited-use tests -- just like they would in
+   * normal production cases.
+   */
+  ALPHA = 2,
+  /**
+   * BETA - Beta is the point at which we are ready to open a release for any
+   * customer to use. There are no SLA or technical support obligations in a
+   * Beta release. Products will be complete from a feature perspective, but
+   * may have some open outstanding issues. Beta releases are suitable for
+   * limited production use cases.
+   */
+  BETA = 3,
+  /**
+   * GA - GA features are open to all developers and are considered stable and
+   * fully qualified for production use.
+   */
+  GA = 4,
+  /**
+   * DEPRECATED - Deprecated features are scheduled to be shut down and removed. For more
+   * information, see the "Deprecation Policy" section of our [Terms of
+   * Service](https://cloud.google.com/terms/)
+   * and the [Google Cloud Platform Subject to the Deprecation
+   * Policy](https://cloud.google.com/terms/deprecation) documentation.
+   */
+  DEPRECATED = 5,
+  UNRECOGNIZED = -1,
+}
+export const LaunchStageSDKType = LaunchStage;
+export const LaunchStageAmino = LaunchStage;
+export function launchStageFromJSON(object: any): LaunchStage {
+  switch (object) {
+    case 0:
+    case "LAUNCH_STAGE_UNSPECIFIED":
+      return LaunchStage.LAUNCH_STAGE_UNSPECIFIED;
+    case 6:
+    case "UNIMPLEMENTED":
+      return LaunchStage.UNIMPLEMENTED;
+    case 7:
+    case "PRELAUNCH":
+      return LaunchStage.PRELAUNCH;
+    case 1:
+    case "EARLY_ACCESS":
+      return LaunchStage.EARLY_ACCESS;
+    case 2:
+    case "ALPHA":
+      return LaunchStage.ALPHA;
+    case 3:
+    case "BETA":
+      return LaunchStage.BETA;
+    case 4:
+    case "GA":
+      return LaunchStage.GA;
+    case 5:
+    case "DEPRECATED":
+      return LaunchStage.DEPRECATED;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return LaunchStage.UNRECOGNIZED;
+  }
+}
+export function launchStageToJSON(object: LaunchStage): string {
+  switch (object) {
+    case LaunchStage.LAUNCH_STAGE_UNSPECIFIED:
+      return "LAUNCH_STAGE_UNSPECIFIED";
+    case LaunchStage.UNIMPLEMENTED:
+      return "UNIMPLEMENTED";
+    case LaunchStage.PRELAUNCH:
+      return "PRELAUNCH";
+    case LaunchStage.EARLY_ACCESS:
+      return "EARLY_ACCESS";
+    case LaunchStage.ALPHA:
+      return "ALPHA";
+    case LaunchStage.BETA:
+      return "BETA";
+    case LaunchStage.GA:
+      return "GA";
+    case LaunchStage.DEPRECATED:
+      return "DEPRECATED";
+    case LaunchStage.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}