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

package/types/google/api/log.ts

@@ -0,0 +1,201 @@
+//@ts-nocheck
+import { LabelDescriptor, LabelDescriptorAmino, LabelDescriptorSDKType } from "./label";
+import { BinaryReader, BinaryWriter } from "../../binary";
+/**
+ * A description of a log type. Example in YAML format:
+ * 
+ *     - name: library.googleapis.com/activity_history
+ *       description: The history of borrowing and returning library items.
+ *       display_name: Activity
+ *       labels:
+ *       - key: /customer_id
+ *         description: Identifier of a library customer
+ */
+export interface LogDescriptor {
+  /**
+   * The name of the log. It must be less than 512 characters long and can
+   * include the following characters: upper- and lower-case alphanumeric
+   * characters [A-Za-z0-9], and punctuation characters including
+   * slash, underscore, hyphen, period [/_-.].
+   */
+  name: string;
+  /**
+   * The set of labels that are available to describe a specific log entry.
+   * Runtime requests that contain labels not specified here are
+   * considered invalid.
+   */
+  labels: LabelDescriptor[];
+  /**
+   * A human-readable description of this log. This information appears in
+   * the documentation and can contain details.
+   */
+  description: string;
+  /**
+   * The human-readable name for this log. This information appears on
+   * the user interface and should be concise.
+   */
+  displayName: string;
+}
+export interface LogDescriptorProtoMsg {
+  typeUrl: "/google.api.LogDescriptor";
+  value: Uint8Array;
+}
+/**
+ * A description of a log type. Example in YAML format:
+ * 
+ *     - name: library.googleapis.com/activity_history
+ *       description: The history of borrowing and returning library items.
+ *       display_name: Activity
+ *       labels:
+ *       - key: /customer_id
+ *         description: Identifier of a library customer
+ * @name LogDescriptorAmino
+ * @package google.api
+ * @see proto type: google.api.LogDescriptor
+ */
+export interface LogDescriptorAmino {
+  /**
+   * The name of the log. It must be less than 512 characters long and can
+   * include the following characters: upper- and lower-case alphanumeric
+   * characters [A-Za-z0-9], and punctuation characters including
+   * slash, underscore, hyphen, period [/_-.].
+   */
+  name?: string;
+  /**
+   * The set of labels that are available to describe a specific log entry.
+   * Runtime requests that contain labels not specified here are
+   * considered invalid.
+   */
+  labels?: LabelDescriptorAmino[];
+  /**
+   * A human-readable description of this log. This information appears in
+   * the documentation and can contain details.
+   */
+  description?: string;
+  /**
+   * The human-readable name for this log. This information appears on
+   * the user interface and should be concise.
+   */
+  display_name?: string;
+}
+export interface LogDescriptorAminoMsg {
+  type: "/google.api.LogDescriptor";
+  value: LogDescriptorAmino;
+}
+/**
+ * A description of a log type. Example in YAML format:
+ * 
+ *     - name: library.googleapis.com/activity_history
+ *       description: The history of borrowing and returning library items.
+ *       display_name: Activity
+ *       labels:
+ *       - key: /customer_id
+ *         description: Identifier of a library customer
+ */
+export interface LogDescriptorSDKType {
+  name: string;
+  labels: LabelDescriptorSDKType[];
+  description: string;
+  display_name: string;
+}
+function createBaseLogDescriptor(): LogDescriptor {
+  return {
+    name: "",
+    labels: [],
+    description: "",
+    displayName: ""
+  };
+}
+export const LogDescriptor = {
+  typeUrl: "/google.api.LogDescriptor",
+  encode(message: LogDescriptor, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+    for (const v of message.labels) {
+      LabelDescriptor.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.description !== "") {
+      writer.uint32(26).string(message.description);
+    }
+    if (message.displayName !== "") {
+      writer.uint32(34).string(message.displayName);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): LogDescriptor {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseLogDescriptor();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.name = reader.string();
+          break;
+        case 2:
+          message.labels.push(LabelDescriptor.decode(reader, reader.uint32()));
+          break;
+        case 3:
+          message.description = reader.string();
+          break;
+        case 4:
+          message.displayName = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<LogDescriptor>): LogDescriptor {
+    const message = createBaseLogDescriptor();
+    message.name = object.name ?? "";
+    message.labels = object.labels?.map(e => LabelDescriptor.fromPartial(e)) || [];
+    message.description = object.description ?? "";
+    message.displayName = object.displayName ?? "";
+    return message;
+  },
+  fromAmino(object: LogDescriptorAmino): LogDescriptor {
+    const message = createBaseLogDescriptor();
+    if (object.name !== undefined && object.name !== null) {
+      message.name = object.name;
+    }
+    message.labels = object.labels?.map(e => LabelDescriptor.fromAmino(e)) || [];
+    if (object.description !== undefined && object.description !== null) {
+      message.description = object.description;
+    }
+    if (object.display_name !== undefined && object.display_name !== null) {
+      message.displayName = object.display_name;
+    }
+    return message;
+  },
+  toAmino(message: LogDescriptor): LogDescriptorAmino {
+    const obj: any = {};
+    obj.name = message.name === "" ? undefined : message.name;
+    if (message.labels) {
+      obj.labels = message.labels.map(e => e ? LabelDescriptor.toAmino(e) : undefined);
+    } else {
+      obj.labels = message.labels;
+    }
+    obj.description = message.description === "" ? undefined : message.description;
+    obj.display_name = message.displayName === "" ? undefined : message.displayName;
+    return obj;
+  },
+  fromAminoMsg(object: LogDescriptorAminoMsg): LogDescriptor {
+    return LogDescriptor.fromAmino(object.value);
+  },
+  fromProtoMsg(message: LogDescriptorProtoMsg): LogDescriptor {
+    return LogDescriptor.decode(message.value);
+  },
+  toProto(message: LogDescriptor): Uint8Array {
+    return LogDescriptor.encode(message).finish();
+  },
+  toProtoMsg(message: LogDescriptor): LogDescriptorProtoMsg {
+    return {
+      typeUrl: "/google.api.LogDescriptor",
+      value: LogDescriptor.encode(message).finish()
+    };
+  }
+};

package/types/google/api/logging.ts

@@ -0,0 +1,355 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../binary";
+/**
+ * Logging configuration of the service.
+ * 
+ * The following example shows how to configure logs to be sent to the
+ * producer and consumer projects. In the example, the `activity_history`
+ * log is sent to both the producer and consumer projects, whereas the
+ * `purchase_history` log is only sent to the producer project.
+ * 
+ *     monitored_resources:
+ *     - type: library.googleapis.com/branch
+ *       labels:
+ *       - key: /city
+ *         description: The city where the library branch is located in.
+ *       - key: /name
+ *         description: The name of the branch.
+ *     logs:
+ *     - name: activity_history
+ *       labels:
+ *       - key: /customer_id
+ *     - name: purchase_history
+ *     logging:
+ *       producer_destinations:
+ *       - monitored_resource: library.googleapis.com/branch
+ *         logs:
+ *         - activity_history
+ *         - purchase_history
+ *       consumer_destinations:
+ *       - monitored_resource: library.googleapis.com/branch
+ *         logs:
+ *         - activity_history
+ */
+export interface Logging {
+  /**
+   * Logging configurations for sending logs to the producer project.
+   * There can be multiple producer destinations, each one must have a
+   * different monitored resource type. A log can be used in at most
+   * one producer destination.
+   */
+  producerDestinations: Logging_LoggingDestination[];
+  /**
+   * Logging configurations for sending logs to the consumer project.
+   * There can be multiple consumer destinations, each one must have a
+   * different monitored resource type. A log can be used in at most
+   * one consumer destination.
+   */
+  consumerDestinations: Logging_LoggingDestination[];
+}
+export interface LoggingProtoMsg {
+  typeUrl: "/google.api.Logging";
+  value: Uint8Array;
+}
+/**
+ * Logging configuration of the service.
+ * 
+ * The following example shows how to configure logs to be sent to the
+ * producer and consumer projects. In the example, the `activity_history`
+ * log is sent to both the producer and consumer projects, whereas the
+ * `purchase_history` log is only sent to the producer project.
+ * 
+ *     monitored_resources:
+ *     - type: library.googleapis.com/branch
+ *       labels:
+ *       - key: /city
+ *         description: The city where the library branch is located in.
+ *       - key: /name
+ *         description: The name of the branch.
+ *     logs:
+ *     - name: activity_history
+ *       labels:
+ *       - key: /customer_id
+ *     - name: purchase_history
+ *     logging:
+ *       producer_destinations:
+ *       - monitored_resource: library.googleapis.com/branch
+ *         logs:
+ *         - activity_history
+ *         - purchase_history
+ *       consumer_destinations:
+ *       - monitored_resource: library.googleapis.com/branch
+ *         logs:
+ *         - activity_history
+ * @name LoggingAmino
+ * @package google.api
+ * @see proto type: google.api.Logging
+ */
+export interface LoggingAmino {
+  /**
+   * Logging configurations for sending logs to the producer project.
+   * There can be multiple producer destinations, each one must have a
+   * different monitored resource type. A log can be used in at most
+   * one producer destination.
+   */
+  producer_destinations?: Logging_LoggingDestinationAmino[];
+  /**
+   * Logging configurations for sending logs to the consumer project.
+   * There can be multiple consumer destinations, each one must have a
+   * different monitored resource type. A log can be used in at most
+   * one consumer destination.
+   */
+  consumer_destinations?: Logging_LoggingDestinationAmino[];
+}
+export interface LoggingAminoMsg {
+  type: "/google.api.Logging";
+  value: LoggingAmino;
+}
+/**
+ * Logging configuration of the service.
+ * 
+ * The following example shows how to configure logs to be sent to the
+ * producer and consumer projects. In the example, the `activity_history`
+ * log is sent to both the producer and consumer projects, whereas the
+ * `purchase_history` log is only sent to the producer project.
+ * 
+ *     monitored_resources:
+ *     - type: library.googleapis.com/branch
+ *       labels:
+ *       - key: /city
+ *         description: The city where the library branch is located in.
+ *       - key: /name
+ *         description: The name of the branch.
+ *     logs:
+ *     - name: activity_history
+ *       labels:
+ *       - key: /customer_id
+ *     - name: purchase_history
+ *     logging:
+ *       producer_destinations:
+ *       - monitored_resource: library.googleapis.com/branch
+ *         logs:
+ *         - activity_history
+ *         - purchase_history
+ *       consumer_destinations:
+ *       - monitored_resource: library.googleapis.com/branch
+ *         logs:
+ *         - activity_history
+ */
+export interface LoggingSDKType {
+  producer_destinations: Logging_LoggingDestinationSDKType[];
+  consumer_destinations: Logging_LoggingDestinationSDKType[];
+}
+/**
+ * Configuration of a specific logging destination (the producer project
+ * or the consumer project).
+ */
+export interface Logging_LoggingDestination {
+  /**
+   * The monitored resource type. The type must be defined in the
+   * [Service.monitored_resources][google.api.Service.monitored_resources]
+   * section.
+   */
+  monitoredResource: string;
+  /**
+   * Names of the logs to be sent to this destination. Each name must
+   * be defined in the [Service.logs][google.api.Service.logs] section. If the
+   * log name is not a domain scoped name, it will be automatically prefixed
+   * with the service name followed by "/".
+   */
+  logs: string[];
+}
+export interface Logging_LoggingDestinationProtoMsg {
+  typeUrl: "/google.api.LoggingDestination";
+  value: Uint8Array;
+}
+/**
+ * Configuration of a specific logging destination (the producer project
+ * or the consumer project).
+ * @name Logging_LoggingDestinationAmino
+ * @package google.api
+ * @see proto type: google.api.Logging_LoggingDestination
+ */
+export interface Logging_LoggingDestinationAmino {
+  /**
+   * The monitored resource type. The type must be defined in the
+   * [Service.monitored_resources][google.api.Service.monitored_resources]
+   * section.
+   */
+  monitored_resource?: string;
+  /**
+   * Names of the logs to be sent to this destination. Each name must
+   * be defined in the [Service.logs][google.api.Service.logs] section. If the
+   * log name is not a domain scoped name, it will be automatically prefixed
+   * with the service name followed by "/".
+   */
+  logs?: string[];
+}
+export interface Logging_LoggingDestinationAminoMsg {
+  type: "/google.api.LoggingDestination";
+  value: Logging_LoggingDestinationAmino;
+}
+/**
+ * Configuration of a specific logging destination (the producer project
+ * or the consumer project).
+ */
+export interface Logging_LoggingDestinationSDKType {
+  monitored_resource: string;
+  logs: string[];
+}
+function createBaseLogging(): Logging {
+  return {
+    producerDestinations: [],
+    consumerDestinations: []
+  };
+}
+export const Logging = {
+  typeUrl: "/google.api.Logging",
+  encode(message: Logging, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.producerDestinations) {
+      Logging_LoggingDestination.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    for (const v of message.consumerDestinations) {
+      Logging_LoggingDestination.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Logging {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseLogging();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.producerDestinations.push(Logging_LoggingDestination.decode(reader, reader.uint32()));
+          break;
+        case 2:
+          message.consumerDestinations.push(Logging_LoggingDestination.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Logging>): Logging {
+    const message = createBaseLogging();
+    message.producerDestinations = object.producerDestinations?.map(e => Logging_LoggingDestination.fromPartial(e)) || [];
+    message.consumerDestinations = object.consumerDestinations?.map(e => Logging_LoggingDestination.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: LoggingAmino): Logging {
+    const message = createBaseLogging();
+    message.producerDestinations = object.producer_destinations?.map(e => Logging_LoggingDestination.fromAmino(e)) || [];
+    message.consumerDestinations = object.consumer_destinations?.map(e => Logging_LoggingDestination.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: Logging): LoggingAmino {
+    const obj: any = {};
+    if (message.producerDestinations) {
+      obj.producer_destinations = message.producerDestinations.map(e => e ? Logging_LoggingDestination.toAmino(e) : undefined);
+    } else {
+      obj.producer_destinations = message.producerDestinations;
+    }
+    if (message.consumerDestinations) {
+      obj.consumer_destinations = message.consumerDestinations.map(e => e ? Logging_LoggingDestination.toAmino(e) : undefined);
+    } else {
+      obj.consumer_destinations = message.consumerDestinations;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: LoggingAminoMsg): Logging {
+    return Logging.fromAmino(object.value);
+  },
+  fromProtoMsg(message: LoggingProtoMsg): Logging {
+    return Logging.decode(message.value);
+  },
+  toProto(message: Logging): Uint8Array {
+    return Logging.encode(message).finish();
+  },
+  toProtoMsg(message: Logging): LoggingProtoMsg {
+    return {
+      typeUrl: "/google.api.Logging",
+      value: Logging.encode(message).finish()
+    };
+  }
+};
+function createBaseLogging_LoggingDestination(): Logging_LoggingDestination {
+  return {
+    monitoredResource: "",
+    logs: []
+  };
+}
+export const Logging_LoggingDestination = {
+  typeUrl: "/google.api.LoggingDestination",
+  encode(message: Logging_LoggingDestination, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.monitoredResource !== "") {
+      writer.uint32(26).string(message.monitoredResource);
+    }
+    for (const v of message.logs) {
+      writer.uint32(10).string(v!);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Logging_LoggingDestination {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseLogging_LoggingDestination();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 3:
+          message.monitoredResource = reader.string();
+          break;
+        case 1:
+          message.logs.push(reader.string());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Logging_LoggingDestination>): Logging_LoggingDestination {
+    const message = createBaseLogging_LoggingDestination();
+    message.monitoredResource = object.monitoredResource ?? "";
+    message.logs = object.logs?.map(e => e) || [];
+    return message;
+  },
+  fromAmino(object: Logging_LoggingDestinationAmino): Logging_LoggingDestination {
+    const message = createBaseLogging_LoggingDestination();
+    if (object.monitored_resource !== undefined && object.monitored_resource !== null) {
+      message.monitoredResource = object.monitored_resource;
+    }
+    message.logs = object.logs?.map(e => e) || [];
+    return message;
+  },
+  toAmino(message: Logging_LoggingDestination): Logging_LoggingDestinationAmino {
+    const obj: any = {};
+    obj.monitored_resource = message.monitoredResource === "" ? undefined : message.monitoredResource;
+    if (message.logs) {
+      obj.logs = message.logs.map(e => e);
+    } else {
+      obj.logs = message.logs;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: Logging_LoggingDestinationAminoMsg): Logging_LoggingDestination {
+    return Logging_LoggingDestination.fromAmino(object.value);
+  },
+  fromProtoMsg(message: Logging_LoggingDestinationProtoMsg): Logging_LoggingDestination {
+    return Logging_LoggingDestination.decode(message.value);
+  },
+  toProto(message: Logging_LoggingDestination): Uint8Array {
+    return Logging_LoggingDestination.encode(message).finish();
+  },
+  toProtoMsg(message: Logging_LoggingDestination): Logging_LoggingDestinationProtoMsg {
+    return {
+      typeUrl: "/google.api.LoggingDestination",
+      value: Logging_LoggingDestination.encode(message).finish()
+    };
+  }
+};