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

package/types/google/api/context.ts

@@ -0,0 +1,418 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../binary";
+/**
+ * `Context` defines which contexts an API requests.
+ * 
+ * Example:
+ * 
+ *     context:
+ *       rules:
+ *       - selector: "*"
+ *         requested:
+ *         - google.rpc.context.ProjectContext
+ *         - google.rpc.context.OriginContext
+ * 
+ * The above specifies that all methods in the API request
+ * `google.rpc.context.ProjectContext` and
+ * `google.rpc.context.OriginContext`.
+ * 
+ * Available context types are defined in package
+ * `google.rpc.context`.
+ * 
+ * This also provides mechanism to allowlist any protobuf message extension that
+ * can be sent in grpc metadata using “x-goog-ext-<extension_id>-bin” and
+ * “x-goog-ext-<extension_id>-jspb” format. For example, list any service
+ * specific protobuf types that can appear in grpc metadata as follows in your
+ * yaml file:
+ * 
+ * Example:
+ * 
+ *     context:
+ *       rules:
+ *        - selector: "google.example.library.v1.LibraryService.CreateBook"
+ *          allowed_request_extensions:
+ *          - google.foo.v1.NewExtension
+ *          allowed_response_extensions:
+ *          - google.foo.v1.NewExtension
+ * 
+ * You can also specify extension ID instead of fully qualified extension name
+ * here.
+ */
+export interface Context {
+  /**
+   * A list of RPC context rules that apply to individual API methods.
+   * 
+   * **NOTE:** All service configuration rules follow "last one wins" order.
+   */
+  rules: ContextRule[];
+}
+export interface ContextProtoMsg {
+  typeUrl: "/google.api.Context";
+  value: Uint8Array;
+}
+/**
+ * `Context` defines which contexts an API requests.
+ * 
+ * Example:
+ * 
+ *     context:
+ *       rules:
+ *       - selector: "*"
+ *         requested:
+ *         - google.rpc.context.ProjectContext
+ *         - google.rpc.context.OriginContext
+ * 
+ * The above specifies that all methods in the API request
+ * `google.rpc.context.ProjectContext` and
+ * `google.rpc.context.OriginContext`.
+ * 
+ * Available context types are defined in package
+ * `google.rpc.context`.
+ * 
+ * This also provides mechanism to allowlist any protobuf message extension that
+ * can be sent in grpc metadata using “x-goog-ext-<extension_id>-bin” and
+ * “x-goog-ext-<extension_id>-jspb” format. For example, list any service
+ * specific protobuf types that can appear in grpc metadata as follows in your
+ * yaml file:
+ * 
+ * Example:
+ * 
+ *     context:
+ *       rules:
+ *        - selector: "google.example.library.v1.LibraryService.CreateBook"
+ *          allowed_request_extensions:
+ *          - google.foo.v1.NewExtension
+ *          allowed_response_extensions:
+ *          - google.foo.v1.NewExtension
+ * 
+ * You can also specify extension ID instead of fully qualified extension name
+ * here.
+ * @name ContextAmino
+ * @package google.api
+ * @see proto type: google.api.Context
+ */
+export interface ContextAmino {
+  /**
+   * A list of RPC context rules that apply to individual API methods.
+   * 
+   * **NOTE:** All service configuration rules follow "last one wins" order.
+   */
+  rules?: ContextRuleAmino[];
+}
+export interface ContextAminoMsg {
+  type: "/google.api.Context";
+  value: ContextAmino;
+}
+/**
+ * `Context` defines which contexts an API requests.
+ * 
+ * Example:
+ * 
+ *     context:
+ *       rules:
+ *       - selector: "*"
+ *         requested:
+ *         - google.rpc.context.ProjectContext
+ *         - google.rpc.context.OriginContext
+ * 
+ * The above specifies that all methods in the API request
+ * `google.rpc.context.ProjectContext` and
+ * `google.rpc.context.OriginContext`.
+ * 
+ * Available context types are defined in package
+ * `google.rpc.context`.
+ * 
+ * This also provides mechanism to allowlist any protobuf message extension that
+ * can be sent in grpc metadata using “x-goog-ext-<extension_id>-bin” and
+ * “x-goog-ext-<extension_id>-jspb” format. For example, list any service
+ * specific protobuf types that can appear in grpc metadata as follows in your
+ * yaml file:
+ * 
+ * Example:
+ * 
+ *     context:
+ *       rules:
+ *        - selector: "google.example.library.v1.LibraryService.CreateBook"
+ *          allowed_request_extensions:
+ *          - google.foo.v1.NewExtension
+ *          allowed_response_extensions:
+ *          - google.foo.v1.NewExtension
+ * 
+ * You can also specify extension ID instead of fully qualified extension name
+ * here.
+ */
+export interface ContextSDKType {
+  rules: ContextRuleSDKType[];
+}
+/**
+ * A context rule provides information about the context for an individual API
+ * element.
+ */
+export interface ContextRule {
+  /**
+   * Selects the methods to which this rule applies.
+   * 
+   * Refer to [selector][google.api.DocumentationRule.selector] for syntax
+   * details.
+   */
+  selector: string;
+  /**
+   * A list of full type names of requested contexts, only the requested context
+   * will be made available to the backend.
+   */
+  requested: string[];
+  /**
+   * A list of full type names of provided contexts. It is used to support
+   * propagating HTTP headers and ETags from the response extension.
+   */
+  provided: string[];
+  /**
+   * A list of full type names or extension IDs of extensions allowed in grpc
+   * side channel from client to backend.
+   */
+  allowedRequestExtensions: string[];
+  /**
+   * A list of full type names or extension IDs of extensions allowed in grpc
+   * side channel from backend to client.
+   */
+  allowedResponseExtensions: string[];
+}
+export interface ContextRuleProtoMsg {
+  typeUrl: "/google.api.ContextRule";
+  value: Uint8Array;
+}
+/**
+ * A context rule provides information about the context for an individual API
+ * element.
+ * @name ContextRuleAmino
+ * @package google.api
+ * @see proto type: google.api.ContextRule
+ */
+export interface ContextRuleAmino {
+  /**
+   * Selects the methods to which this rule applies.
+   * 
+   * Refer to [selector][google.api.DocumentationRule.selector] for syntax
+   * details.
+   */
+  selector?: string;
+  /**
+   * A list of full type names of requested contexts, only the requested context
+   * will be made available to the backend.
+   */
+  requested?: string[];
+  /**
+   * A list of full type names of provided contexts. It is used to support
+   * propagating HTTP headers and ETags from the response extension.
+   */
+  provided?: string[];
+  /**
+   * A list of full type names or extension IDs of extensions allowed in grpc
+   * side channel from client to backend.
+   */
+  allowed_request_extensions?: string[];
+  /**
+   * A list of full type names or extension IDs of extensions allowed in grpc
+   * side channel from backend to client.
+   */
+  allowed_response_extensions?: string[];
+}
+export interface ContextRuleAminoMsg {
+  type: "/google.api.ContextRule";
+  value: ContextRuleAmino;
+}
+/**
+ * A context rule provides information about the context for an individual API
+ * element.
+ */
+export interface ContextRuleSDKType {
+  selector: string;
+  requested: string[];
+  provided: string[];
+  allowed_request_extensions: string[];
+  allowed_response_extensions: string[];
+}
+function createBaseContext(): Context {
+  return {
+    rules: []
+  };
+}
+export const Context = {
+  typeUrl: "/google.api.Context",
+  encode(message: Context, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.rules) {
+      ContextRule.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Context {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseContext();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.rules.push(ContextRule.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Context>): Context {
+    const message = createBaseContext();
+    message.rules = object.rules?.map(e => ContextRule.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: ContextAmino): Context {
+    const message = createBaseContext();
+    message.rules = object.rules?.map(e => ContextRule.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: Context): ContextAmino {
+    const obj: any = {};
+    if (message.rules) {
+      obj.rules = message.rules.map(e => e ? ContextRule.toAmino(e) : undefined);
+    } else {
+      obj.rules = message.rules;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: ContextAminoMsg): Context {
+    return Context.fromAmino(object.value);
+  },
+  fromProtoMsg(message: ContextProtoMsg): Context {
+    return Context.decode(message.value);
+  },
+  toProto(message: Context): Uint8Array {
+    return Context.encode(message).finish();
+  },
+  toProtoMsg(message: Context): ContextProtoMsg {
+    return {
+      typeUrl: "/google.api.Context",
+      value: Context.encode(message).finish()
+    };
+  }
+};
+function createBaseContextRule(): ContextRule {
+  return {
+    selector: "",
+    requested: [],
+    provided: [],
+    allowedRequestExtensions: [],
+    allowedResponseExtensions: []
+  };
+}
+export const ContextRule = {
+  typeUrl: "/google.api.ContextRule",
+  encode(message: ContextRule, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.selector !== "") {
+      writer.uint32(10).string(message.selector);
+    }
+    for (const v of message.requested) {
+      writer.uint32(18).string(v!);
+    }
+    for (const v of message.provided) {
+      writer.uint32(26).string(v!);
+    }
+    for (const v of message.allowedRequestExtensions) {
+      writer.uint32(34).string(v!);
+    }
+    for (const v of message.allowedResponseExtensions) {
+      writer.uint32(42).string(v!);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ContextRule {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseContextRule();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.selector = reader.string();
+          break;
+        case 2:
+          message.requested.push(reader.string());
+          break;
+        case 3:
+          message.provided.push(reader.string());
+          break;
+        case 4:
+          message.allowedRequestExtensions.push(reader.string());
+          break;
+        case 5:
+          message.allowedResponseExtensions.push(reader.string());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<ContextRule>): ContextRule {
+    const message = createBaseContextRule();
+    message.selector = object.selector ?? "";
+    message.requested = object.requested?.map(e => e) || [];
+    message.provided = object.provided?.map(e => e) || [];
+    message.allowedRequestExtensions = object.allowedRequestExtensions?.map(e => e) || [];
+    message.allowedResponseExtensions = object.allowedResponseExtensions?.map(e => e) || [];
+    return message;
+  },
+  fromAmino(object: ContextRuleAmino): ContextRule {
+    const message = createBaseContextRule();
+    if (object.selector !== undefined && object.selector !== null) {
+      message.selector = object.selector;
+    }
+    message.requested = object.requested?.map(e => e) || [];
+    message.provided = object.provided?.map(e => e) || [];
+    message.allowedRequestExtensions = object.allowed_request_extensions?.map(e => e) || [];
+    message.allowedResponseExtensions = object.allowed_response_extensions?.map(e => e) || [];
+    return message;
+  },
+  toAmino(message: ContextRule): ContextRuleAmino {
+    const obj: any = {};
+    obj.selector = message.selector === "" ? undefined : message.selector;
+    if (message.requested) {
+      obj.requested = message.requested.map(e => e);
+    } else {
+      obj.requested = message.requested;
+    }
+    if (message.provided) {
+      obj.provided = message.provided.map(e => e);
+    } else {
+      obj.provided = message.provided;
+    }
+    if (message.allowedRequestExtensions) {
+      obj.allowed_request_extensions = message.allowedRequestExtensions.map(e => e);
+    } else {
+      obj.allowed_request_extensions = message.allowedRequestExtensions;
+    }
+    if (message.allowedResponseExtensions) {
+      obj.allowed_response_extensions = message.allowedResponseExtensions.map(e => e);
+    } else {
+      obj.allowed_response_extensions = message.allowedResponseExtensions;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: ContextRuleAminoMsg): ContextRule {
+    return ContextRule.fromAmino(object.value);
+  },
+  fromProtoMsg(message: ContextRuleProtoMsg): ContextRule {
+    return ContextRule.decode(message.value);
+  },
+  toProto(message: ContextRule): Uint8Array {
+    return ContextRule.encode(message).finish();
+  },
+  toProtoMsg(message: ContextRule): ContextRuleProtoMsg {
+    return {
+      typeUrl: "/google.api.ContextRule",
+      value: ContextRule.encode(message).finish()
+    };
+  }
+};

package/types/google/api/control.ts

@@ -0,0 +1,141 @@
+//@ts-nocheck
+import { MethodPolicy, MethodPolicyAmino, MethodPolicySDKType } from "./policy";
+import { BinaryReader, BinaryWriter } from "../../binary";
+/**
+ * Selects and configures the service controller used by the service.
+ * 
+ * Example:
+ * 
+ *     control:
+ *       environment: servicecontrol.googleapis.com
+ */
+export interface Control {
+  /**
+   * The service controller environment to use. If empty, no control plane
+   * feature (like quota and billing) will be enabled. The recommended value for
+   * most services is servicecontrol.googleapis.com
+   */
+  environment: string;
+  /** Defines policies applying to the API methods of the service. */
+  methodPolicies: MethodPolicy[];
+}
+export interface ControlProtoMsg {
+  typeUrl: "/google.api.Control";
+  value: Uint8Array;
+}
+/**
+ * Selects and configures the service controller used by the service.
+ * 
+ * Example:
+ * 
+ *     control:
+ *       environment: servicecontrol.googleapis.com
+ * @name ControlAmino
+ * @package google.api
+ * @see proto type: google.api.Control
+ */
+export interface ControlAmino {
+  /**
+   * The service controller environment to use. If empty, no control plane
+   * feature (like quota and billing) will be enabled. The recommended value for
+   * most services is servicecontrol.googleapis.com
+   */
+  environment?: string;
+  /**
+   * Defines policies applying to the API methods of the service.
+   */
+  method_policies?: MethodPolicyAmino[];
+}
+export interface ControlAminoMsg {
+  type: "/google.api.Control";
+  value: ControlAmino;
+}
+/**
+ * Selects and configures the service controller used by the service.
+ * 
+ * Example:
+ * 
+ *     control:
+ *       environment: servicecontrol.googleapis.com
+ */
+export interface ControlSDKType {
+  environment: string;
+  method_policies: MethodPolicySDKType[];
+}
+function createBaseControl(): Control {
+  return {
+    environment: "",
+    methodPolicies: []
+  };
+}
+export const Control = {
+  typeUrl: "/google.api.Control",
+  encode(message: Control, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.environment !== "") {
+      writer.uint32(10).string(message.environment);
+    }
+    for (const v of message.methodPolicies) {
+      MethodPolicy.encode(v!, writer.uint32(34).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Control {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseControl();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.environment = reader.string();
+          break;
+        case 4:
+          message.methodPolicies.push(MethodPolicy.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Control>): Control {
+    const message = createBaseControl();
+    message.environment = object.environment ?? "";
+    message.methodPolicies = object.methodPolicies?.map(e => MethodPolicy.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: ControlAmino): Control {
+    const message = createBaseControl();
+    if (object.environment !== undefined && object.environment !== null) {
+      message.environment = object.environment;
+    }
+    message.methodPolicies = object.method_policies?.map(e => MethodPolicy.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: Control): ControlAmino {
+    const obj: any = {};
+    obj.environment = message.environment === "" ? undefined : message.environment;
+    if (message.methodPolicies) {
+      obj.method_policies = message.methodPolicies.map(e => e ? MethodPolicy.toAmino(e) : undefined);
+    } else {
+      obj.method_policies = message.methodPolicies;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: ControlAminoMsg): Control {
+    return Control.fromAmino(object.value);
+  },
+  fromProtoMsg(message: ControlProtoMsg): Control {
+    return Control.decode(message.value);
+  },
+  toProto(message: Control): Uint8Array {
+    return Control.encode(message).finish();
+  },
+  toProtoMsg(message: Control): ControlProtoMsg {
+    return {
+      typeUrl: "/google.api.Control",
+      value: Control.encode(message).finish()
+    };
+  }
+};