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

package/types/google/api/source_info.ts

@@ -0,0 +1,97 @@
+//@ts-nocheck
+import { Any, AnyAmino, AnySDKType } from "../protobuf/any";
+import { BinaryReader, BinaryWriter } from "../../binary";
+/** Source information used to create a Service Config */
+export interface SourceInfo {
+  /** All files used during config generation. */
+  sourceFiles: Any[];
+}
+export interface SourceInfoProtoMsg {
+  typeUrl: "/google.api.SourceInfo";
+  value: Uint8Array;
+}
+/**
+ * Source information used to create a Service Config
+ * @name SourceInfoAmino
+ * @package google.api
+ * @see proto type: google.api.SourceInfo
+ */
+export interface SourceInfoAmino {
+  /**
+   * All files used during config generation.
+   */
+  source_files?: AnyAmino[];
+}
+export interface SourceInfoAminoMsg {
+  type: "/google.api.SourceInfo";
+  value: SourceInfoAmino;
+}
+/** Source information used to create a Service Config */
+export interface SourceInfoSDKType {
+  source_files: AnySDKType[];
+}
+function createBaseSourceInfo(): SourceInfo {
+  return {
+    sourceFiles: []
+  };
+}
+export const SourceInfo = {
+  typeUrl: "/google.api.SourceInfo",
+  encode(message: SourceInfo, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.sourceFiles) {
+      Any.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): SourceInfo {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSourceInfo();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.sourceFiles.push(Any.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<SourceInfo>): SourceInfo {
+    const message = createBaseSourceInfo();
+    message.sourceFiles = object.sourceFiles?.map(e => Any.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: SourceInfoAmino): SourceInfo {
+    const message = createBaseSourceInfo();
+    message.sourceFiles = object.source_files?.map(e => Any.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: SourceInfo): SourceInfoAmino {
+    const obj: any = {};
+    if (message.sourceFiles) {
+      obj.source_files = message.sourceFiles.map(e => e ? Any.toAmino(e) : undefined);
+    } else {
+      obj.source_files = message.sourceFiles;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: SourceInfoAminoMsg): SourceInfo {
+    return SourceInfo.fromAmino(object.value);
+  },
+  fromProtoMsg(message: SourceInfoProtoMsg): SourceInfo {
+    return SourceInfo.decode(message.value);
+  },
+  toProto(message: SourceInfo): Uint8Array {
+    return SourceInfo.encode(message).finish();
+  },
+  toProtoMsg(message: SourceInfo): SourceInfoProtoMsg {
+    return {
+      typeUrl: "/google.api.SourceInfo",
+      value: SourceInfo.encode(message).finish()
+    };
+  }
+};

package/types/google/api/system_parameter.ts

@@ -0,0 +1,461 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../binary";
+/**
+ * ### System parameter configuration
+ * 
+ * A system parameter is a special kind of parameter defined by the API
+ * system, not by an individual API. It is typically mapped to an HTTP header
+ * and/or a URL query parameter. This configuration specifies which methods
+ * change the names of the system parameters.
+ */
+export interface SystemParameters {
+  /**
+   * Define system parameters.
+   * 
+   * The parameters defined here will override the default parameters
+   * implemented by the system. If this field is missing from the service
+   * config, default system parameters will be used. Default system parameters
+   * and names is implementation-dependent.
+   * 
+   * Example: define api key for all methods
+   * 
+   *     system_parameters
+   *       rules:
+   *         - selector: "*"
+   *           parameters:
+   *             - name: api_key
+   *               url_query_parameter: api_key
+   * 
+   * 
+   * Example: define 2 api key names for a specific method.
+   * 
+   *     system_parameters
+   *       rules:
+   *         - selector: "/ListShelves"
+   *           parameters:
+   *             - name: api_key
+   *               http_header: Api-Key1
+   *             - name: api_key
+   *               http_header: Api-Key2
+   * 
+   * **NOTE:** All service configuration rules follow "last one wins" order.
+   */
+  rules: SystemParameterRule[];
+}
+export interface SystemParametersProtoMsg {
+  typeUrl: "/google.api.SystemParameters";
+  value: Uint8Array;
+}
+/**
+ * ### System parameter configuration
+ * 
+ * A system parameter is a special kind of parameter defined by the API
+ * system, not by an individual API. It is typically mapped to an HTTP header
+ * and/or a URL query parameter. This configuration specifies which methods
+ * change the names of the system parameters.
+ * @name SystemParametersAmino
+ * @package google.api
+ * @see proto type: google.api.SystemParameters
+ */
+export interface SystemParametersAmino {
+  /**
+   * Define system parameters.
+   * 
+   * The parameters defined here will override the default parameters
+   * implemented by the system. If this field is missing from the service
+   * config, default system parameters will be used. Default system parameters
+   * and names is implementation-dependent.
+   * 
+   * Example: define api key for all methods
+   * 
+   *     system_parameters
+   *       rules:
+   *         - selector: "*"
+   *           parameters:
+   *             - name: api_key
+   *               url_query_parameter: api_key
+   * 
+   * 
+   * Example: define 2 api key names for a specific method.
+   * 
+   *     system_parameters
+   *       rules:
+   *         - selector: "/ListShelves"
+   *           parameters:
+   *             - name: api_key
+   *               http_header: Api-Key1
+   *             - name: api_key
+   *               http_header: Api-Key2
+   * 
+   * **NOTE:** All service configuration rules follow "last one wins" order.
+   */
+  rules?: SystemParameterRuleAmino[];
+}
+export interface SystemParametersAminoMsg {
+  type: "/google.api.SystemParameters";
+  value: SystemParametersAmino;
+}
+/**
+ * ### System parameter configuration
+ * 
+ * A system parameter is a special kind of parameter defined by the API
+ * system, not by an individual API. It is typically mapped to an HTTP header
+ * and/or a URL query parameter. This configuration specifies which methods
+ * change the names of the system parameters.
+ */
+export interface SystemParametersSDKType {
+  rules: SystemParameterRuleSDKType[];
+}
+/**
+ * Define a system parameter rule mapping system parameter definitions to
+ * methods.
+ */
+export interface SystemParameterRule {
+  /**
+   * Selects the methods to which this rule applies. Use '*' to indicate all
+   * methods in all APIs.
+   * 
+   * Refer to [selector][google.api.DocumentationRule.selector] for syntax
+   * details.
+   */
+  selector: string;
+  /**
+   * Define parameters. Multiple names may be defined for a parameter.
+   * For a given method call, only one of them should be used. If multiple
+   * names are used the behavior is implementation-dependent.
+   * If none of the specified names are present the behavior is
+   * parameter-dependent.
+   */
+  parameters: SystemParameter[];
+}
+export interface SystemParameterRuleProtoMsg {
+  typeUrl: "/google.api.SystemParameterRule";
+  value: Uint8Array;
+}
+/**
+ * Define a system parameter rule mapping system parameter definitions to
+ * methods.
+ * @name SystemParameterRuleAmino
+ * @package google.api
+ * @see proto type: google.api.SystemParameterRule
+ */
+export interface SystemParameterRuleAmino {
+  /**
+   * Selects the methods to which this rule applies. Use '*' to indicate all
+   * methods in all APIs.
+   * 
+   * Refer to [selector][google.api.DocumentationRule.selector] for syntax
+   * details.
+   */
+  selector?: string;
+  /**
+   * Define parameters. Multiple names may be defined for a parameter.
+   * For a given method call, only one of them should be used. If multiple
+   * names are used the behavior is implementation-dependent.
+   * If none of the specified names are present the behavior is
+   * parameter-dependent.
+   */
+  parameters?: SystemParameterAmino[];
+}
+export interface SystemParameterRuleAminoMsg {
+  type: "/google.api.SystemParameterRule";
+  value: SystemParameterRuleAmino;
+}
+/**
+ * Define a system parameter rule mapping system parameter definitions to
+ * methods.
+ */
+export interface SystemParameterRuleSDKType {
+  selector: string;
+  parameters: SystemParameterSDKType[];
+}
+/**
+ * Define a parameter's name and location. The parameter may be passed as either
+ * an HTTP header or a URL query parameter, and if both are passed the behavior
+ * is implementation-dependent.
+ */
+export interface SystemParameter {
+  /** Define the name of the parameter, such as "api_key" . It is case sensitive. */
+  name: string;
+  /**
+   * Define the HTTP header name to use for the parameter. It is case
+   * insensitive.
+   */
+  httpHeader: string;
+  /**
+   * Define the URL query parameter name to use for the parameter. It is case
+   * sensitive.
+   */
+  urlQueryParameter: string;
+}
+export interface SystemParameterProtoMsg {
+  typeUrl: "/google.api.SystemParameter";
+  value: Uint8Array;
+}
+/**
+ * Define a parameter's name and location. The parameter may be passed as either
+ * an HTTP header or a URL query parameter, and if both are passed the behavior
+ * is implementation-dependent.
+ * @name SystemParameterAmino
+ * @package google.api
+ * @see proto type: google.api.SystemParameter
+ */
+export interface SystemParameterAmino {
+  /**
+   * Define the name of the parameter, such as "api_key" . It is case sensitive.
+   */
+  name?: string;
+  /**
+   * Define the HTTP header name to use for the parameter. It is case
+   * insensitive.
+   */
+  http_header?: string;
+  /**
+   * Define the URL query parameter name to use for the parameter. It is case
+   * sensitive.
+   */
+  url_query_parameter?: string;
+}
+export interface SystemParameterAminoMsg {
+  type: "/google.api.SystemParameter";
+  value: SystemParameterAmino;
+}
+/**
+ * Define a parameter's name and location. The parameter may be passed as either
+ * an HTTP header or a URL query parameter, and if both are passed the behavior
+ * is implementation-dependent.
+ */
+export interface SystemParameterSDKType {
+  name: string;
+  http_header: string;
+  url_query_parameter: string;
+}
+function createBaseSystemParameters(): SystemParameters {
+  return {
+    rules: []
+  };
+}
+export const SystemParameters = {
+  typeUrl: "/google.api.SystemParameters",
+  encode(message: SystemParameters, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.rules) {
+      SystemParameterRule.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): SystemParameters {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSystemParameters();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.rules.push(SystemParameterRule.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<SystemParameters>): SystemParameters {
+    const message = createBaseSystemParameters();
+    message.rules = object.rules?.map(e => SystemParameterRule.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: SystemParametersAmino): SystemParameters {
+    const message = createBaseSystemParameters();
+    message.rules = object.rules?.map(e => SystemParameterRule.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: SystemParameters): SystemParametersAmino {
+    const obj: any = {};
+    if (message.rules) {
+      obj.rules = message.rules.map(e => e ? SystemParameterRule.toAmino(e) : undefined);
+    } else {
+      obj.rules = message.rules;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: SystemParametersAminoMsg): SystemParameters {
+    return SystemParameters.fromAmino(object.value);
+  },
+  fromProtoMsg(message: SystemParametersProtoMsg): SystemParameters {
+    return SystemParameters.decode(message.value);
+  },
+  toProto(message: SystemParameters): Uint8Array {
+    return SystemParameters.encode(message).finish();
+  },
+  toProtoMsg(message: SystemParameters): SystemParametersProtoMsg {
+    return {
+      typeUrl: "/google.api.SystemParameters",
+      value: SystemParameters.encode(message).finish()
+    };
+  }
+};
+function createBaseSystemParameterRule(): SystemParameterRule {
+  return {
+    selector: "",
+    parameters: []
+  };
+}
+export const SystemParameterRule = {
+  typeUrl: "/google.api.SystemParameterRule",
+  encode(message: SystemParameterRule, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.selector !== "") {
+      writer.uint32(10).string(message.selector);
+    }
+    for (const v of message.parameters) {
+      SystemParameter.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): SystemParameterRule {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSystemParameterRule();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.selector = reader.string();
+          break;
+        case 2:
+          message.parameters.push(SystemParameter.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<SystemParameterRule>): SystemParameterRule {
+    const message = createBaseSystemParameterRule();
+    message.selector = object.selector ?? "";
+    message.parameters = object.parameters?.map(e => SystemParameter.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: SystemParameterRuleAmino): SystemParameterRule {
+    const message = createBaseSystemParameterRule();
+    if (object.selector !== undefined && object.selector !== null) {
+      message.selector = object.selector;
+    }
+    message.parameters = object.parameters?.map(e => SystemParameter.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: SystemParameterRule): SystemParameterRuleAmino {
+    const obj: any = {};
+    obj.selector = message.selector === "" ? undefined : message.selector;
+    if (message.parameters) {
+      obj.parameters = message.parameters.map(e => e ? SystemParameter.toAmino(e) : undefined);
+    } else {
+      obj.parameters = message.parameters;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: SystemParameterRuleAminoMsg): SystemParameterRule {
+    return SystemParameterRule.fromAmino(object.value);
+  },
+  fromProtoMsg(message: SystemParameterRuleProtoMsg): SystemParameterRule {
+    return SystemParameterRule.decode(message.value);
+  },
+  toProto(message: SystemParameterRule): Uint8Array {
+    return SystemParameterRule.encode(message).finish();
+  },
+  toProtoMsg(message: SystemParameterRule): SystemParameterRuleProtoMsg {
+    return {
+      typeUrl: "/google.api.SystemParameterRule",
+      value: SystemParameterRule.encode(message).finish()
+    };
+  }
+};
+function createBaseSystemParameter(): SystemParameter {
+  return {
+    name: "",
+    httpHeader: "",
+    urlQueryParameter: ""
+  };
+}
+export const SystemParameter = {
+  typeUrl: "/google.api.SystemParameter",
+  encode(message: SystemParameter, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+    if (message.httpHeader !== "") {
+      writer.uint32(18).string(message.httpHeader);
+    }
+    if (message.urlQueryParameter !== "") {
+      writer.uint32(26).string(message.urlQueryParameter);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): SystemParameter {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSystemParameter();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.name = reader.string();
+          break;
+        case 2:
+          message.httpHeader = reader.string();
+          break;
+        case 3:
+          message.urlQueryParameter = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<SystemParameter>): SystemParameter {
+    const message = createBaseSystemParameter();
+    message.name = object.name ?? "";
+    message.httpHeader = object.httpHeader ?? "";
+    message.urlQueryParameter = object.urlQueryParameter ?? "";
+    return message;
+  },
+  fromAmino(object: SystemParameterAmino): SystemParameter {
+    const message = createBaseSystemParameter();
+    if (object.name !== undefined && object.name !== null) {
+      message.name = object.name;
+    }
+    if (object.http_header !== undefined && object.http_header !== null) {
+      message.httpHeader = object.http_header;
+    }
+    if (object.url_query_parameter !== undefined && object.url_query_parameter !== null) {
+      message.urlQueryParameter = object.url_query_parameter;
+    }
+    return message;
+  },
+  toAmino(message: SystemParameter): SystemParameterAmino {
+    const obj: any = {};
+    obj.name = message.name === "" ? undefined : message.name;
+    obj.http_header = message.httpHeader === "" ? undefined : message.httpHeader;
+    obj.url_query_parameter = message.urlQueryParameter === "" ? undefined : message.urlQueryParameter;
+    return obj;
+  },
+  fromAminoMsg(object: SystemParameterAminoMsg): SystemParameter {
+    return SystemParameter.fromAmino(object.value);
+  },
+  fromProtoMsg(message: SystemParameterProtoMsg): SystemParameter {
+    return SystemParameter.decode(message.value);
+  },
+  toProto(message: SystemParameter): Uint8Array {
+    return SystemParameter.encode(message).finish();
+  },
+  toProtoMsg(message: SystemParameter): SystemParameterProtoMsg {
+    return {
+      typeUrl: "/google.api.SystemParameter",
+      value: SystemParameter.encode(message).finish()
+    };
+  }
+};