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

package/types/google/api/visibility.ts

@@ -0,0 +1,328 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../binary";
+/**
+ * `Visibility` restricts service consumer's access to service elements,
+ * such as whether an application can call a visibility-restricted method.
+ * The restriction is expressed by applying visibility labels on service
+ * elements. The visibility labels are elsewhere linked to service consumers.
+ * 
+ * A service can define multiple visibility labels, but a service consumer
+ * should be granted at most one visibility label. Multiple visibility
+ * labels for a single service consumer are not supported.
+ * 
+ * If an element and all its parents have no visibility label, its visibility
+ * is unconditionally granted.
+ * 
+ * Example:
+ * 
+ *     visibility:
+ *       rules:
+ *       - selector: google.calendar.Calendar.EnhancedSearch
+ *         restriction: PREVIEW
+ *       - selector: google.calendar.Calendar.Delegate
+ *         restriction: INTERNAL
+ * 
+ * Here, all methods are publicly visible except for the restricted methods
+ * EnhancedSearch and Delegate.
+ */
+export interface Visibility {
+  /**
+   * A list of visibility rules that apply to individual API elements.
+   * 
+   * **NOTE:** All service configuration rules follow "last one wins" order.
+   */
+  rules: VisibilityRule[];
+}
+export interface VisibilityProtoMsg {
+  typeUrl: "/google.api.Visibility";
+  value: Uint8Array;
+}
+/**
+ * `Visibility` restricts service consumer's access to service elements,
+ * such as whether an application can call a visibility-restricted method.
+ * The restriction is expressed by applying visibility labels on service
+ * elements. The visibility labels are elsewhere linked to service consumers.
+ * 
+ * A service can define multiple visibility labels, but a service consumer
+ * should be granted at most one visibility label. Multiple visibility
+ * labels for a single service consumer are not supported.
+ * 
+ * If an element and all its parents have no visibility label, its visibility
+ * is unconditionally granted.
+ * 
+ * Example:
+ * 
+ *     visibility:
+ *       rules:
+ *       - selector: google.calendar.Calendar.EnhancedSearch
+ *         restriction: PREVIEW
+ *       - selector: google.calendar.Calendar.Delegate
+ *         restriction: INTERNAL
+ * 
+ * Here, all methods are publicly visible except for the restricted methods
+ * EnhancedSearch and Delegate.
+ * @name VisibilityAmino
+ * @package google.api
+ * @see proto type: google.api.Visibility
+ */
+export interface VisibilityAmino {
+  /**
+   * A list of visibility rules that apply to individual API elements.
+   * 
+   * **NOTE:** All service configuration rules follow "last one wins" order.
+   */
+  rules?: VisibilityRuleAmino[];
+}
+export interface VisibilityAminoMsg {
+  type: "/google.api.Visibility";
+  value: VisibilityAmino;
+}
+/**
+ * `Visibility` restricts service consumer's access to service elements,
+ * such as whether an application can call a visibility-restricted method.
+ * The restriction is expressed by applying visibility labels on service
+ * elements. The visibility labels are elsewhere linked to service consumers.
+ * 
+ * A service can define multiple visibility labels, but a service consumer
+ * should be granted at most one visibility label. Multiple visibility
+ * labels for a single service consumer are not supported.
+ * 
+ * If an element and all its parents have no visibility label, its visibility
+ * is unconditionally granted.
+ * 
+ * Example:
+ * 
+ *     visibility:
+ *       rules:
+ *       - selector: google.calendar.Calendar.EnhancedSearch
+ *         restriction: PREVIEW
+ *       - selector: google.calendar.Calendar.Delegate
+ *         restriction: INTERNAL
+ * 
+ * Here, all methods are publicly visible except for the restricted methods
+ * EnhancedSearch and Delegate.
+ */
+export interface VisibilitySDKType {
+  rules: VisibilityRuleSDKType[];
+}
+/**
+ * A visibility rule provides visibility configuration for an individual API
+ * element.
+ */
+export interface VisibilityRule {
+  /**
+   * Selects methods, messages, fields, enums, etc. to which this rule applies.
+   * 
+   * Refer to [selector][google.api.DocumentationRule.selector] for syntax
+   * details.
+   */
+  selector: string;
+  /**
+   * A comma-separated list of visibility labels that apply to the `selector`.
+   * Any of the listed labels can be used to grant the visibility.
+   * 
+   * If a rule has multiple labels, removing one of the labels but not all of
+   * them can break clients.
+   * 
+   * Example:
+   * 
+   *     visibility:
+   *       rules:
+   *       - selector: google.calendar.Calendar.EnhancedSearch
+   *         restriction: INTERNAL, PREVIEW
+   * 
+   * Removing INTERNAL from this restriction will break clients that rely on
+   * this method and only had access to it through INTERNAL.
+   */
+  restriction: string;
+}
+export interface VisibilityRuleProtoMsg {
+  typeUrl: "/google.api.VisibilityRule";
+  value: Uint8Array;
+}
+/**
+ * A visibility rule provides visibility configuration for an individual API
+ * element.
+ * @name VisibilityRuleAmino
+ * @package google.api
+ * @see proto type: google.api.VisibilityRule
+ */
+export interface VisibilityRuleAmino {
+  /**
+   * Selects methods, messages, fields, enums, etc. to which this rule applies.
+   * 
+   * Refer to [selector][google.api.DocumentationRule.selector] for syntax
+   * details.
+   */
+  selector?: string;
+  /**
+   * A comma-separated list of visibility labels that apply to the `selector`.
+   * Any of the listed labels can be used to grant the visibility.
+   * 
+   * If a rule has multiple labels, removing one of the labels but not all of
+   * them can break clients.
+   * 
+   * Example:
+   * 
+   *     visibility:
+   *       rules:
+   *       - selector: google.calendar.Calendar.EnhancedSearch
+   *         restriction: INTERNAL, PREVIEW
+   * 
+   * Removing INTERNAL from this restriction will break clients that rely on
+   * this method and only had access to it through INTERNAL.
+   */
+  restriction?: string;
+}
+export interface VisibilityRuleAminoMsg {
+  type: "/google.api.VisibilityRule";
+  value: VisibilityRuleAmino;
+}
+/**
+ * A visibility rule provides visibility configuration for an individual API
+ * element.
+ */
+export interface VisibilityRuleSDKType {
+  selector: string;
+  restriction: string;
+}
+function createBaseVisibility(): Visibility {
+  return {
+    rules: []
+  };
+}
+export const Visibility = {
+  typeUrl: "/google.api.Visibility",
+  encode(message: Visibility, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.rules) {
+      VisibilityRule.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Visibility {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseVisibility();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.rules.push(VisibilityRule.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Visibility>): Visibility {
+    const message = createBaseVisibility();
+    message.rules = object.rules?.map(e => VisibilityRule.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: VisibilityAmino): Visibility {
+    const message = createBaseVisibility();
+    message.rules = object.rules?.map(e => VisibilityRule.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: Visibility): VisibilityAmino {
+    const obj: any = {};
+    if (message.rules) {
+      obj.rules = message.rules.map(e => e ? VisibilityRule.toAmino(e) : undefined);
+    } else {
+      obj.rules = message.rules;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: VisibilityAminoMsg): Visibility {
+    return Visibility.fromAmino(object.value);
+  },
+  fromProtoMsg(message: VisibilityProtoMsg): Visibility {
+    return Visibility.decode(message.value);
+  },
+  toProto(message: Visibility): Uint8Array {
+    return Visibility.encode(message).finish();
+  },
+  toProtoMsg(message: Visibility): VisibilityProtoMsg {
+    return {
+      typeUrl: "/google.api.Visibility",
+      value: Visibility.encode(message).finish()
+    };
+  }
+};
+function createBaseVisibilityRule(): VisibilityRule {
+  return {
+    selector: "",
+    restriction: ""
+  };
+}
+export const VisibilityRule = {
+  typeUrl: "/google.api.VisibilityRule",
+  encode(message: VisibilityRule, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.selector !== "") {
+      writer.uint32(10).string(message.selector);
+    }
+    if (message.restriction !== "") {
+      writer.uint32(18).string(message.restriction);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): VisibilityRule {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseVisibilityRule();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.selector = reader.string();
+          break;
+        case 2:
+          message.restriction = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<VisibilityRule>): VisibilityRule {
+    const message = createBaseVisibilityRule();
+    message.selector = object.selector ?? "";
+    message.restriction = object.restriction ?? "";
+    return message;
+  },
+  fromAmino(object: VisibilityRuleAmino): VisibilityRule {
+    const message = createBaseVisibilityRule();
+    if (object.selector !== undefined && object.selector !== null) {
+      message.selector = object.selector;
+    }
+    if (object.restriction !== undefined && object.restriction !== null) {
+      message.restriction = object.restriction;
+    }
+    return message;
+  },
+  toAmino(message: VisibilityRule): VisibilityRuleAmino {
+    const obj: any = {};
+    obj.selector = message.selector === "" ? undefined : message.selector;
+    obj.restriction = message.restriction === "" ? undefined : message.restriction;
+    return obj;
+  },
+  fromAminoMsg(object: VisibilityRuleAminoMsg): VisibilityRule {
+    return VisibilityRule.fromAmino(object.value);
+  },
+  fromProtoMsg(message: VisibilityRuleProtoMsg): VisibilityRule {
+    return VisibilityRule.decode(message.value);
+  },
+  toProto(message: VisibilityRule): Uint8Array {
+    return VisibilityRule.encode(message).finish();
+  },
+  toProtoMsg(message: VisibilityRule): VisibilityRuleProtoMsg {
+    return {
+      typeUrl: "/google.api.VisibilityRule",
+      value: VisibilityRule.encode(message).finish()
+    };
+  }
+};

package/types/google/bundle.ts

@@ -0,0 +1,115 @@
+//@ts-nocheck
+import * as _157 from "./api/annotations";
+import * as _158 from "./api/auth";
+import * as _159 from "./api/backend";
+import * as _160 from "./api/billing";
+import * as _161 from "./api/client";
+import * as _162 from "./api/config_change";
+import * as _163 from "./api/consumer";
+import * as _164 from "./api/context";
+import * as _165 from "./api/control";
+import * as _166 from "./api/distribution";
+import * as _167 from "./api/documentation";
+import * as _168 from "./api/endpoint";
+import * as _169 from "./api/error_reason";
+import * as _170 from "./api/field_behavior";
+import * as _171 from "./api/field_info";
+import * as _172 from "./api/http";
+import * as _173 from "./api/httpbody";
+import * as _174 from "./api/label";
+import * as _175 from "./api/launch_stage";
+import * as _176 from "./api/log";
+import * as _177 from "./api/logging";
+import * as _178 from "./api/metric";
+import * as _179 from "./api/monitored_resource";
+import * as _180 from "./api/monitoring";
+import * as _181 from "./api/policy";
+import * as _182 from "./api/quota";
+import * as _183 from "./api/resource";
+import * as _184 from "./api/routing";
+import * as _185 from "./api/service";
+import * as _186 from "./api/source_info";
+import * as _187 from "./api/system_parameter";
+import * as _188 from "./api/usage";
+import * as _189 from "./api/visibility";
+import * as _190 from "./logging/type/log_severity";
+import * as _191 from "./longrunning/operations";
+import * as _192 from "./protobuf/any";
+import * as _193 from "./protobuf/api";
+import * as _194 from "./protobuf/descriptor";
+import * as _195 from "./protobuf/duration";
+import * as _196 from "./protobuf/empty";
+import * as _197 from "./protobuf/field_mask";
+import * as _198 from "./protobuf/source_context";
+import * as _199 from "./protobuf/struct";
+import * as _200 from "./protobuf/timestamp";
+import * as _201 from "./protobuf/type";
+import * as _202 from "./protobuf/wrappers";
+import * as _203 from "./rpc/code";
+import * as _204 from "./rpc/error_details";
+import * as _205 from "./rpc/http";
+import * as _206 from "./rpc/status";
+export namespace google {
+  export const api = {
+    ..._157,
+    ..._158,
+    ..._159,
+    ..._160,
+    ..._161,
+    ..._162,
+    ..._163,
+    ..._164,
+    ..._165,
+    ..._166,
+    ..._167,
+    ..._168,
+    ..._169,
+    ..._170,
+    ..._171,
+    ..._172,
+    ..._173,
+    ..._174,
+    ..._175,
+    ..._176,
+    ..._177,
+    ..._178,
+    ..._179,
+    ..._180,
+    ..._181,
+    ..._182,
+    ..._183,
+    ..._184,
+    ..._185,
+    ..._186,
+    ..._187,
+    ..._188,
+    ..._189
+  };
+  export namespace logging {
+    export const type = {
+      ..._190
+    };
+  }
+  export const longrunning = {
+    ..._191
+  };
+  export const protobuf = {
+    ..._192,
+    ..._193,
+    ..._194,
+    ..._195,
+    ..._196,
+    ..._197,
+    ..._198,
+    ..._199,
+    ..._200,
+    ..._201,
+    ..._202
+  };
+  export const rpc = {
+    ..._203,
+    ..._204,
+    ..._205,
+    ..._206
+  };
+}

package/types/google/logging/type/log_severity.ts

@@ -0,0 +1,104 @@
+//@ts-nocheck
+/**
+ * The severity of the event described in a log entry, expressed as one of the
+ * standard severity levels listed below.  For your reference, the levels are
+ * assigned the listed numeric values. The effect of using numeric values other
+ * than those listed is undefined.
+ * 
+ * You can filter for log entries by severity.  For example, the following
+ * filter expression will match log entries with severities `INFO`, `NOTICE`,
+ * and `WARNING`:
+ * 
+ *     severity > DEBUG AND severity <= WARNING
+ * 
+ * If you are writing log entries, you should map other severity encodings to
+ * one of these standard levels. For example, you might map all of Java's FINE,
+ * FINER, and FINEST levels to `LogSeverity.DEBUG`. You can preserve the
+ * original severity level in the log entry payload if you wish.
+ */
+export enum LogSeverity {
+  /** DEFAULT - (0) The log entry has no assigned severity level. */
+  DEFAULT = 0,
+  /** DEBUG - (100) Debug or trace information. */
+  DEBUG = 100,
+  /** INFO - (200) Routine information, such as ongoing status or performance. */
+  INFO = 200,
+  /**
+   * NOTICE - (300) Normal but significant events, such as start up, shut down, or
+   * a configuration change.
+   */
+  NOTICE = 300,
+  /** WARNING - (400) Warning events might cause problems. */
+  WARNING = 400,
+  /** ERROR - (500) Error events are likely to cause problems. */
+  ERROR = 500,
+  /** CRITICAL - (600) Critical events cause more severe problems or outages. */
+  CRITICAL = 600,
+  /** ALERT - (700) A person must take an action immediately. */
+  ALERT = 700,
+  /** EMERGENCY - (800) One or more systems are unusable. */
+  EMERGENCY = 800,
+  UNRECOGNIZED = -1,
+}
+export const LogSeveritySDKType = LogSeverity;
+export const LogSeverityAmino = LogSeverity;
+export function logSeverityFromJSON(object: any): LogSeverity {
+  switch (object) {
+    case 0:
+    case "DEFAULT":
+      return LogSeverity.DEFAULT;
+    case 100:
+    case "DEBUG":
+      return LogSeverity.DEBUG;
+    case 200:
+    case "INFO":
+      return LogSeverity.INFO;
+    case 300:
+    case "NOTICE":
+      return LogSeverity.NOTICE;
+    case 400:
+    case "WARNING":
+      return LogSeverity.WARNING;
+    case 500:
+    case "ERROR":
+      return LogSeverity.ERROR;
+    case 600:
+    case "CRITICAL":
+      return LogSeverity.CRITICAL;
+    case 700:
+    case "ALERT":
+      return LogSeverity.ALERT;
+    case 800:
+    case "EMERGENCY":
+      return LogSeverity.EMERGENCY;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return LogSeverity.UNRECOGNIZED;
+  }
+}
+export function logSeverityToJSON(object: LogSeverity): string {
+  switch (object) {
+    case LogSeverity.DEFAULT:
+      return "DEFAULT";
+    case LogSeverity.DEBUG:
+      return "DEBUG";
+    case LogSeverity.INFO:
+      return "INFO";
+    case LogSeverity.NOTICE:
+      return "NOTICE";
+    case LogSeverity.WARNING:
+      return "WARNING";
+    case LogSeverity.ERROR:
+      return "ERROR";
+    case LogSeverity.CRITICAL:
+      return "CRITICAL";
+    case LogSeverity.ALERT:
+      return "ALERT";
+    case LogSeverity.EMERGENCY:
+      return "EMERGENCY";
+    case LogSeverity.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}