@agoric/client-utils 0.1.1-other-dev-3eb1a1d.0 → 0.1.1-other-dev-fbe72e7.0.fbe72e7

package/dist/codegen/google/bundle.d.ts

@@ -0,0 +1,375 @@
+import * as _123 from './protobuf/any.js';
+import * as _124 from './protobuf/descriptor.js';
+import * as _125 from './protobuf/duration.js';
+import * as _126 from './protobuf/empty.js';
+import * as _127 from './protobuf/timestamp.js';
+export declare namespace google {
+    const protobuf: {
+        Timestamp: {
+            typeUrl: "/google.protobuf.Timestamp";
+            encode(message: _127.Timestamp, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _127.Timestamp;
+            fromJSON(object: any): _127.Timestamp;
+            toJSON(message: _127.Timestamp): import("../json-safe.js").JsonSafe<_127.Timestamp>;
+            fromPartial(object: Partial<_127.Timestamp>): _127.Timestamp;
+            fromProtoMsg(message: _127.TimestampProtoMsg): _127.Timestamp;
+            toProto(message: _127.Timestamp): Uint8Array;
+            toProtoMsg(message: _127.Timestamp): _127.TimestampProtoMsg;
+        };
+        Empty: {
+            typeUrl: "/google.protobuf.Empty";
+            encode(_: _126.Empty, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _126.Empty;
+            fromJSON(_: any): _126.Empty;
+            toJSON(_: _126.Empty): import("../json-safe.js").JsonSafe<_126.Empty>;
+            fromPartial(_: Partial<_126.Empty>): _126.Empty;
+            fromProtoMsg(message: _126.EmptyProtoMsg): _126.Empty;
+            toProto(message: _126.Empty): Uint8Array;
+            toProtoMsg(message: _126.Empty): _126.EmptyProtoMsg;
+        };
+        Duration: {
+            typeUrl: "/google.protobuf.Duration";
+            encode(message: _125.Duration, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _125.Duration;
+            fromJSON(object: any): _125.Duration;
+            toJSON(message: _125.Duration): import("../json-safe.js").JsonSafe<_125.Duration>;
+            fromPartial(object: Partial<_125.Duration>): _125.Duration;
+            fromProtoMsg(message: _125.DurationProtoMsg): _125.Duration;
+            toProto(message: _125.Duration): Uint8Array;
+            toProtoMsg(message: _125.Duration): _125.DurationProtoMsg;
+        };
+        fieldDescriptorProto_TypeFromJSON(object: any): _124.FieldDescriptorProto_Type;
+        fieldDescriptorProto_TypeToJSON(object: _124.FieldDescriptorProto_Type): string;
+        fieldDescriptorProto_LabelFromJSON(object: any): _124.FieldDescriptorProto_Label;
+        fieldDescriptorProto_LabelToJSON(object: _124.FieldDescriptorProto_Label): string;
+        fileOptions_OptimizeModeFromJSON(object: any): _124.FileOptions_OptimizeMode;
+        fileOptions_OptimizeModeToJSON(object: _124.FileOptions_OptimizeMode): string;
+        fieldOptions_CTypeFromJSON(object: any): _124.FieldOptions_CType;
+        fieldOptions_CTypeToJSON(object: _124.FieldOptions_CType): string;
+        fieldOptions_JSTypeFromJSON(object: any): _124.FieldOptions_JSType;
+        fieldOptions_JSTypeToJSON(object: _124.FieldOptions_JSType): string;
+        methodOptions_IdempotencyLevelFromJSON(object: any): _124.MethodOptions_IdempotencyLevel;
+        methodOptions_IdempotencyLevelToJSON(object: _124.MethodOptions_IdempotencyLevel): string;
+        FieldDescriptorProto_Type: typeof _124.FieldDescriptorProto_Type;
+        FieldDescriptorProto_TypeSDKType: typeof _124.FieldDescriptorProto_Type;
+        FieldDescriptorProto_Label: typeof _124.FieldDescriptorProto_Label;
+        FieldDescriptorProto_LabelSDKType: typeof _124.FieldDescriptorProto_Label;
+        FileOptions_OptimizeMode: typeof _124.FileOptions_OptimizeMode;
+        FileOptions_OptimizeModeSDKType: typeof _124.FileOptions_OptimizeMode;
+        FieldOptions_CType: typeof _124.FieldOptions_CType;
+        FieldOptions_CTypeSDKType: typeof _124.FieldOptions_CType;
+        FieldOptions_JSType: typeof _124.FieldOptions_JSType;
+        FieldOptions_JSTypeSDKType: typeof _124.FieldOptions_JSType;
+        MethodOptions_IdempotencyLevel: typeof _124.MethodOptions_IdempotencyLevel;
+        MethodOptions_IdempotencyLevelSDKType: typeof _124.MethodOptions_IdempotencyLevel;
+        FileDescriptorSet: {
+            typeUrl: "/google.protobuf.FileDescriptorSet";
+            encode(message: _124.FileDescriptorSet, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.FileDescriptorSet;
+            fromJSON(object: any): _124.FileDescriptorSet;
+            toJSON(message: _124.FileDescriptorSet): import("../json-safe.js").JsonSafe<_124.FileDescriptorSet>;
+            fromPartial(object: Partial<_124.FileDescriptorSet>): _124.FileDescriptorSet;
+            fromProtoMsg(message: _124.FileDescriptorSetProtoMsg): _124.FileDescriptorSet;
+            toProto(message: _124.FileDescriptorSet): Uint8Array;
+            toProtoMsg(message: _124.FileDescriptorSet): _124.FileDescriptorSetProtoMsg;
+        };
+        FileDescriptorProto: {
+            typeUrl: "/google.protobuf.FileDescriptorProto";
+            encode(message: _124.FileDescriptorProto, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.FileDescriptorProto;
+            fromJSON(object: any): _124.FileDescriptorProto;
+            toJSON(message: _124.FileDescriptorProto): import("../json-safe.js").JsonSafe<_124.FileDescriptorProto>;
+            fromPartial(object: Partial<_124.FileDescriptorProto>): _124.FileDescriptorProto;
+            fromProtoMsg(message: _124.FileDescriptorProtoProtoMsg): _124.FileDescriptorProto;
+            toProto(message: _124.FileDescriptorProto): Uint8Array;
+            toProtoMsg(message: _124.FileDescriptorProto): _124.FileDescriptorProtoProtoMsg;
+        };
+        DescriptorProto: {
+            typeUrl: "/google.protobuf.DescriptorProto";
+            encode(message: _124.DescriptorProto, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.DescriptorProto;
+            fromJSON(object: any): _124.DescriptorProto;
+            toJSON(message: _124.DescriptorProto): import("../json-safe.js").JsonSafe<_124.DescriptorProto>;
+            fromPartial(object: Partial<_124.DescriptorProto>): _124.DescriptorProto;
+            fromProtoMsg(message: _124.DescriptorProtoProtoMsg): _124.DescriptorProto;
+            toProto(message: _124.DescriptorProto): Uint8Array;
+            toProtoMsg(message: _124.DescriptorProto): _124.DescriptorProtoProtoMsg;
+        };
+        DescriptorProto_ExtensionRange: {
+            typeUrl: "/google.protobuf.ExtensionRange";
+            encode(message: _124.DescriptorProto_ExtensionRange, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.DescriptorProto_ExtensionRange;
+            fromJSON(object: any): _124.DescriptorProto_ExtensionRange;
+            toJSON(message: _124.DescriptorProto_ExtensionRange): import("../json-safe.js").JsonSafe<_124.DescriptorProto_ExtensionRange>;
+            fromPartial(object: Partial<_124.DescriptorProto_ExtensionRange>): _124.DescriptorProto_ExtensionRange;
+            fromProtoMsg(message: _124.DescriptorProto_ExtensionRangeProtoMsg): _124.DescriptorProto_ExtensionRange;
+            toProto(message: _124.DescriptorProto_ExtensionRange): Uint8Array;
+            toProtoMsg(message: _124.DescriptorProto_ExtensionRange): _124.DescriptorProto_ExtensionRangeProtoMsg;
+        };
+        DescriptorProto_ReservedRange: {
+            typeUrl: "/google.protobuf.ReservedRange";
+            encode(message: _124.DescriptorProto_ReservedRange, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.DescriptorProto_ReservedRange;
+            fromJSON(object: any): _124.DescriptorProto_ReservedRange;
+            toJSON(message: _124.DescriptorProto_ReservedRange): import("../json-safe.js").JsonSafe<_124.DescriptorProto_ReservedRange>;
+            fromPartial(object: Partial<_124.DescriptorProto_ReservedRange>): _124.DescriptorProto_ReservedRange;
+            fromProtoMsg(message: _124.DescriptorProto_ReservedRangeProtoMsg): _124.DescriptorProto_ReservedRange;
+            toProto(message: _124.DescriptorProto_ReservedRange): Uint8Array;
+            toProtoMsg(message: _124.DescriptorProto_ReservedRange): _124.DescriptorProto_ReservedRangeProtoMsg;
+        };
+        ExtensionRangeOptions: {
+            typeUrl: "/google.protobuf.ExtensionRangeOptions";
+            encode(message: _124.ExtensionRangeOptions, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ExtensionRangeOptions;
+            fromJSON(object: any): _124.ExtensionRangeOptions;
+            toJSON(message: _124.ExtensionRangeOptions): import("../json-safe.js").JsonSafe<_124.ExtensionRangeOptions>;
+            fromPartial(object: Partial<_124.ExtensionRangeOptions>): _124.ExtensionRangeOptions;
+            fromProtoMsg(message: _124.ExtensionRangeOptionsProtoMsg): _124.ExtensionRangeOptions;
+            toProto(message: _124.ExtensionRangeOptions): Uint8Array;
+            toProtoMsg(message: _124.ExtensionRangeOptions): _124.ExtensionRangeOptionsProtoMsg;
+        };
+        FieldDescriptorProto: {
+            typeUrl: "/google.protobuf.FieldDescriptorProto";
+            encode(message: _124.FieldDescriptorProto, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.FieldDescriptorProto;
+            fromJSON(object: any): _124.FieldDescriptorProto;
+            toJSON(message: _124.FieldDescriptorProto): import("../json-safe.js").JsonSafe<_124.FieldDescriptorProto>;
+            fromPartial(object: Partial<_124.FieldDescriptorProto>): _124.FieldDescriptorProto;
+            fromProtoMsg(message: _124.FieldDescriptorProtoProtoMsg): _124.FieldDescriptorProto;
+            toProto(message: _124.FieldDescriptorProto): Uint8Array;
+            toProtoMsg(message: _124.FieldDescriptorProto): _124.FieldDescriptorProtoProtoMsg;
+        };
+        OneofDescriptorProto: {
+            typeUrl: "/google.protobuf.OneofDescriptorProto";
+            encode(message: _124.OneofDescriptorProto, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.OneofDescriptorProto;
+            fromJSON(object: any): _124.OneofDescriptorProto;
+            toJSON(message: _124.OneofDescriptorProto): import("../json-safe.js").JsonSafe<_124.OneofDescriptorProto>;
+            fromPartial(object: Partial<_124.OneofDescriptorProto>): _124.OneofDescriptorProto;
+            fromProtoMsg(message: _124.OneofDescriptorProtoProtoMsg): _124.OneofDescriptorProto;
+            toProto(message: _124.OneofDescriptorProto): Uint8Array;
+            toProtoMsg(message: _124.OneofDescriptorProto): _124.OneofDescriptorProtoProtoMsg;
+        };
+        EnumDescriptorProto: {
+            typeUrl: "/google.protobuf.EnumDescriptorProto";
+            encode(message: _124.EnumDescriptorProto, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.EnumDescriptorProto;
+            fromJSON(object: any): _124.EnumDescriptorProto;
+            toJSON(message: _124.EnumDescriptorProto): import("../json-safe.js").JsonSafe<_124.EnumDescriptorProto>;
+            fromPartial(object: Partial<_124.EnumDescriptorProto>): _124.EnumDescriptorProto;
+            fromProtoMsg(message: _124.EnumDescriptorProtoProtoMsg): _124.EnumDescriptorProto;
+            toProto(message: _124.EnumDescriptorProto): Uint8Array;
+            toProtoMsg(message: _124.EnumDescriptorProto): _124.EnumDescriptorProtoProtoMsg;
+        };
+        EnumDescriptorProto_EnumReservedRange: {
+            typeUrl: "/google.protobuf.EnumReservedRange";
+            encode(message: _124.EnumDescriptorProto_EnumReservedRange, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.EnumDescriptorProto_EnumReservedRange;
+            fromJSON(object: any): _124.EnumDescriptorProto_EnumReservedRange;
+            toJSON(message: _124.EnumDescriptorProto_EnumReservedRange): import("../json-safe.js").JsonSafe<_124.EnumDescriptorProto_EnumReservedRange>;
+            fromPartial(object: Partial<_124.EnumDescriptorProto_EnumReservedRange>): _124.EnumDescriptorProto_EnumReservedRange;
+            fromProtoMsg(message: _124.EnumDescriptorProto_EnumReservedRangeProtoMsg): _124.EnumDescriptorProto_EnumReservedRange;
+            toProto(message: _124.EnumDescriptorProto_EnumReservedRange): Uint8Array;
+            toProtoMsg(message: _124.EnumDescriptorProto_EnumReservedRange): _124.EnumDescriptorProto_EnumReservedRangeProtoMsg;
+        };
+        EnumValueDescriptorProto: {
+            typeUrl: "/google.protobuf.EnumValueDescriptorProto";
+            encode(message: _124.EnumValueDescriptorProto, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.EnumValueDescriptorProto;
+            fromJSON(object: any): _124.EnumValueDescriptorProto;
+            toJSON(message: _124.EnumValueDescriptorProto): import("../json-safe.js").JsonSafe<_124.EnumValueDescriptorProto>;
+            fromPartial(object: Partial<_124.EnumValueDescriptorProto>): _124.EnumValueDescriptorProto;
+            fromProtoMsg(message: _124.EnumValueDescriptorProtoProtoMsg): _124.EnumValueDescriptorProto;
+            toProto(message: _124.EnumValueDescriptorProto): Uint8Array;
+            toProtoMsg(message: _124.EnumValueDescriptorProto): _124.EnumValueDescriptorProtoProtoMsg;
+        };
+        ServiceDescriptorProto: {
+            typeUrl: "/google.protobuf.ServiceDescriptorProto";
+            encode(message: _124.ServiceDescriptorProto, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ServiceDescriptorProto;
+            fromJSON(object: any): _124.ServiceDescriptorProto;
+            toJSON(message: _124.ServiceDescriptorProto): import("../json-safe.js").JsonSafe<_124.ServiceDescriptorProto>;
+            fromPartial(object: Partial<_124.ServiceDescriptorProto>): _124.ServiceDescriptorProto;
+            fromProtoMsg(message: _124.ServiceDescriptorProtoProtoMsg): _124.ServiceDescriptorProto;
+            toProto(message: _124.ServiceDescriptorProto): Uint8Array;
+            toProtoMsg(message: _124.ServiceDescriptorProto): _124.ServiceDescriptorProtoProtoMsg;
+        };
+        MethodDescriptorProto: {
+            typeUrl: "/google.protobuf.MethodDescriptorProto";
+            encode(message: _124.MethodDescriptorProto, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.MethodDescriptorProto;
+            fromJSON(object: any): _124.MethodDescriptorProto;
+            toJSON(message: _124.MethodDescriptorProto): import("../json-safe.js").JsonSafe<_124.MethodDescriptorProto>;
+            fromPartial(object: Partial<_124.MethodDescriptorProto>): _124.MethodDescriptorProto;
+            fromProtoMsg(message: _124.MethodDescriptorProtoProtoMsg): _124.MethodDescriptorProto;
+            toProto(message: _124.MethodDescriptorProto): Uint8Array;
+            toProtoMsg(message: _124.MethodDescriptorProto): _124.MethodDescriptorProtoProtoMsg;
+        };
+        FileOptions: {
+            typeUrl: "/google.protobuf.FileOptions";
+            encode(message: _124.FileOptions, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.FileOptions;
+            fromJSON(object: any): _124.FileOptions;
+            toJSON(message: _124.FileOptions): import("../json-safe.js").JsonSafe<_124.FileOptions>;
+            fromPartial(object: Partial<_124.FileOptions>): _124.FileOptions;
+            fromProtoMsg(message: _124.FileOptionsProtoMsg): _124.FileOptions;
+            toProto(message: _124.FileOptions): Uint8Array;
+            toProtoMsg(message: _124.FileOptions): _124.FileOptionsProtoMsg;
+        };
+        MessageOptions: {
+            typeUrl: "/google.protobuf.MessageOptions";
+            encode(message: _124.MessageOptions, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.MessageOptions;
+            fromJSON(object: any): _124.MessageOptions;
+            toJSON(message: _124.MessageOptions): import("../json-safe.js").JsonSafe<_124.MessageOptions>;
+            fromPartial(object: Partial<_124.MessageOptions>): _124.MessageOptions;
+            fromProtoMsg(message: _124.MessageOptionsProtoMsg): _124.MessageOptions;
+            toProto(message: _124.MessageOptions): Uint8Array;
+            toProtoMsg(message: _124.MessageOptions): _124.MessageOptionsProtoMsg;
+        };
+        FieldOptions: {
+            typeUrl: "/google.protobuf.FieldOptions";
+            encode(message: _124.FieldOptions, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.FieldOptions;
+            fromJSON(object: any): _124.FieldOptions;
+            toJSON(message: _124.FieldOptions): import("../json-safe.js").JsonSafe<_124.FieldOptions>;
+            fromPartial(object: Partial<_124.FieldOptions>): _124.FieldOptions;
+            fromProtoMsg(message: _124.FieldOptionsProtoMsg): _124.FieldOptions;
+            toProto(message: _124.FieldOptions): Uint8Array;
+            toProtoMsg(message: _124.FieldOptions): _124.FieldOptionsProtoMsg;
+        };
+        OneofOptions: {
+            typeUrl: "/google.protobuf.OneofOptions";
+            encode(message: _124.OneofOptions, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.OneofOptions;
+            fromJSON(object: any): _124.OneofOptions;
+            toJSON(message: _124.OneofOptions): import("../json-safe.js").JsonSafe<_124.OneofOptions>;
+            fromPartial(object: Partial<_124.OneofOptions>): _124.OneofOptions;
+            fromProtoMsg(message: _124.OneofOptionsProtoMsg): _124.OneofOptions;
+            toProto(message: _124.OneofOptions): Uint8Array;
+            toProtoMsg(message: _124.OneofOptions): _124.OneofOptionsProtoMsg;
+        };
+        EnumOptions: {
+            typeUrl: "/google.protobuf.EnumOptions";
+            encode(message: _124.EnumOptions, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.EnumOptions;
+            fromJSON(object: any): _124.EnumOptions;
+            toJSON(message: _124.EnumOptions): import("../json-safe.js").JsonSafe<_124.EnumOptions>;
+            fromPartial(object: Partial<_124.EnumOptions>): _124.EnumOptions;
+            fromProtoMsg(message: _124.EnumOptionsProtoMsg): _124.EnumOptions;
+            toProto(message: _124.EnumOptions): Uint8Array;
+            toProtoMsg(message: _124.EnumOptions): _124.EnumOptionsProtoMsg;
+        };
+        EnumValueOptions: {
+            typeUrl: "/google.protobuf.EnumValueOptions";
+            encode(message: _124.EnumValueOptions, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.EnumValueOptions;
+            fromJSON(object: any): _124.EnumValueOptions;
+            toJSON(message: _124.EnumValueOptions): import("../json-safe.js").JsonSafe<_124.EnumValueOptions>;
+            fromPartial(object: Partial<_124.EnumValueOptions>): _124.EnumValueOptions;
+            fromProtoMsg(message: _124.EnumValueOptionsProtoMsg): _124.EnumValueOptions;
+            toProto(message: _124.EnumValueOptions): Uint8Array;
+            toProtoMsg(message: _124.EnumValueOptions): _124.EnumValueOptionsProtoMsg;
+        };
+        ServiceOptions: {
+            typeUrl: "/google.protobuf.ServiceOptions";
+            encode(message: _124.ServiceOptions, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ServiceOptions;
+            fromJSON(object: any): _124.ServiceOptions;
+            toJSON(message: _124.ServiceOptions): import("../json-safe.js").JsonSafe<_124.ServiceOptions>;
+            fromPartial(object: Partial<_124.ServiceOptions>): _124.ServiceOptions;
+            fromProtoMsg(message: _124.ServiceOptionsProtoMsg): _124.ServiceOptions;
+            toProto(message: _124.ServiceOptions): Uint8Array;
+            toProtoMsg(message: _124.ServiceOptions): _124.ServiceOptionsProtoMsg;
+        };
+        MethodOptions: {
+            typeUrl: "/google.protobuf.MethodOptions";
+            encode(message: _124.MethodOptions, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.MethodOptions;
+            fromJSON(object: any): _124.MethodOptions;
+            toJSON(message: _124.MethodOptions): import("../json-safe.js").JsonSafe<_124.MethodOptions>;
+            fromPartial(object: Partial<_124.MethodOptions>): _124.MethodOptions;
+            fromProtoMsg(message: _124.MethodOptionsProtoMsg): _124.MethodOptions;
+            toProto(message: _124.MethodOptions): Uint8Array;
+            toProtoMsg(message: _124.MethodOptions): _124.MethodOptionsProtoMsg;
+        };
+        UninterpretedOption: {
+            typeUrl: "/google.protobuf.UninterpretedOption";
+            encode(message: _124.UninterpretedOption, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.UninterpretedOption;
+            fromJSON(object: any): _124.UninterpretedOption;
+            toJSON(message: _124.UninterpretedOption): import("../json-safe.js").JsonSafe<_124.UninterpretedOption>;
+            fromPartial(object: Partial<_124.UninterpretedOption>): _124.UninterpretedOption;
+            fromProtoMsg(message: _124.UninterpretedOptionProtoMsg): _124.UninterpretedOption;
+            toProto(message: _124.UninterpretedOption): Uint8Array;
+            toProtoMsg(message: _124.UninterpretedOption): _124.UninterpretedOptionProtoMsg;
+        };
+        UninterpretedOption_NamePart: {
+            typeUrl: "/google.protobuf.NamePart";
+            encode(message: _124.UninterpretedOption_NamePart, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.UninterpretedOption_NamePart;
+            fromJSON(object: any): _124.UninterpretedOption_NamePart;
+            toJSON(message: _124.UninterpretedOption_NamePart): import("../json-safe.js").JsonSafe<_124.UninterpretedOption_NamePart>;
+            fromPartial(object: Partial<_124.UninterpretedOption_NamePart>): _124.UninterpretedOption_NamePart;
+            fromProtoMsg(message: _124.UninterpretedOption_NamePartProtoMsg): _124.UninterpretedOption_NamePart;
+            toProto(message: _124.UninterpretedOption_NamePart): Uint8Array;
+            toProtoMsg(message: _124.UninterpretedOption_NamePart): _124.UninterpretedOption_NamePartProtoMsg;
+        };
+        SourceCodeInfo: {
+            typeUrl: "/google.protobuf.SourceCodeInfo";
+            encode(message: _124.SourceCodeInfo, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.SourceCodeInfo;
+            fromJSON(object: any): _124.SourceCodeInfo;
+            toJSON(message: _124.SourceCodeInfo): import("../json-safe.js").JsonSafe<_124.SourceCodeInfo>;
+            fromPartial(object: Partial<_124.SourceCodeInfo>): _124.SourceCodeInfo;
+            fromProtoMsg(message: _124.SourceCodeInfoProtoMsg): _124.SourceCodeInfo;
+            toProto(message: _124.SourceCodeInfo): Uint8Array;
+            toProtoMsg(message: _124.SourceCodeInfo): _124.SourceCodeInfoProtoMsg;
+        };
+        SourceCodeInfo_Location: {
+            typeUrl: "/google.protobuf.Location";
+            encode(message: _124.SourceCodeInfo_Location, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.SourceCodeInfo_Location;
+            fromJSON(object: any): _124.SourceCodeInfo_Location;
+            toJSON(message: _124.SourceCodeInfo_Location): import("../json-safe.js").JsonSafe<_124.SourceCodeInfo_Location>;
+            fromPartial(object: Partial<_124.SourceCodeInfo_Location>): _124.SourceCodeInfo_Location;
+            fromProtoMsg(message: _124.SourceCodeInfo_LocationProtoMsg): _124.SourceCodeInfo_Location;
+            toProto(message: _124.SourceCodeInfo_Location): Uint8Array;
+            toProtoMsg(message: _124.SourceCodeInfo_Location): _124.SourceCodeInfo_LocationProtoMsg;
+        };
+        GeneratedCodeInfo: {
+            typeUrl: "/google.protobuf.GeneratedCodeInfo";
+            encode(message: _124.GeneratedCodeInfo, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.GeneratedCodeInfo;
+            fromJSON(object: any): _124.GeneratedCodeInfo;
+            toJSON(message: _124.GeneratedCodeInfo): import("../json-safe.js").JsonSafe<_124.GeneratedCodeInfo>;
+            fromPartial(object: Partial<_124.GeneratedCodeInfo>): _124.GeneratedCodeInfo;
+            fromProtoMsg(message: _124.GeneratedCodeInfoProtoMsg): _124.GeneratedCodeInfo;
+            toProto(message: _124.GeneratedCodeInfo): Uint8Array;
+            toProtoMsg(message: _124.GeneratedCodeInfo): _124.GeneratedCodeInfoProtoMsg;
+        };
+        GeneratedCodeInfo_Annotation: {
+            typeUrl: "/google.protobuf.Annotation";
+            encode(message: _124.GeneratedCodeInfo_Annotation, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.GeneratedCodeInfo_Annotation;
+            fromJSON(object: any): _124.GeneratedCodeInfo_Annotation;
+            toJSON(message: _124.GeneratedCodeInfo_Annotation): import("../json-safe.js").JsonSafe<_124.GeneratedCodeInfo_Annotation>;
+            fromPartial(object: Partial<_124.GeneratedCodeInfo_Annotation>): _124.GeneratedCodeInfo_Annotation;
+            fromProtoMsg(message: _124.GeneratedCodeInfo_AnnotationProtoMsg): _124.GeneratedCodeInfo_Annotation;
+            toProto(message: _124.GeneratedCodeInfo_Annotation): Uint8Array;
+            toProtoMsg(message: _124.GeneratedCodeInfo_Annotation): _124.GeneratedCodeInfo_AnnotationProtoMsg;
+        };
+        Any: {
+            typeUrl: "/google.protobuf.Any";
+            encode(message: _123.Any, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _123.Any;
+            fromJSON(object: any): _123.Any;
+            toJSON(message: _123.Any): import("../json-safe.js").JsonSafe<_123.Any>;
+            fromPartial(object: Partial<_123.Any>): _123.Any;
+            fromProtoMsg(message: _123.AnyProtoMsg): _123.Any;
+            toProto(message: _123.Any): Uint8Array;
+            toProtoMsg(message: _123.Any): _123.AnyProtoMsg;
+        };
+    };
+}
+//# sourceMappingURL=bundle.d.ts.map

package/dist/codegen/google/bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../../src/codegen/google/bundle.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,IAAI,MAAM,mBAAmB,CAAC;AAC1C,OAAO,KAAK,IAAI,MAAM,0BAA0B,CAAC;AACjD,OAAO,KAAK,IAAI,MAAM,wBAAwB,CAAC;AAC/C,OAAO,KAAK,IAAI,MAAM,qBAAqB,CAAC;AAC5C,OAAO,KAAK,IAAI,MAAM,yBAAyB,CAAC;AAChD,yBAAiB,MAAM,CAAC;IACf,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMpB,CAAC;CACH"}

package/dist/codegen/google/bundle.js

@@ -0,0 +1,17 @@
+//@ts-nocheck
+import * as _123 from './protobuf/any.js';
+import * as _124 from './protobuf/descriptor.js';
+import * as _125 from './protobuf/duration.js';
+import * as _126 from './protobuf/empty.js';
+import * as _127 from './protobuf/timestamp.js';
+export var google;
+(function (google) {
+    google.protobuf = {
+        ..._123,
+        ..._124,
+        ..._125,
+        ..._126,
+        ..._127,
+    };
+})(google || (google = {}));
+//# sourceMappingURL=bundle.js.map

package/dist/codegen/google/bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.js","sourceRoot":"","sources":["../../../src/codegen/google/bundle.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,OAAO,KAAK,IAAI,MAAM,mBAAmB,CAAC;AAC1C,OAAO,KAAK,IAAI,MAAM,0BAA0B,CAAC;AACjD,OAAO,KAAK,IAAI,MAAM,wBAAwB,CAAC;AAC/C,OAAO,KAAK,IAAI,MAAM,qBAAqB,CAAC;AAC5C,OAAO,KAAK,IAAI,MAAM,yBAAyB,CAAC;AAChD,MAAM,KAAW,MAAM,CAQtB;AARD,WAAiB,MAAM;IACR,eAAQ,GAAG;QACtB,GAAG,IAAI;QACP,GAAG,IAAI;QACP,GAAG,IAAI;QACP,GAAG,IAAI;QACP,GAAG,IAAI;KACR,CAAC;AACJ,CAAC,EARgB,MAAM,KAAN,MAAM,QAQtB"}

package/dist/codegen/google/protobuf/any.d.ts

@@ -0,0 +1,226 @@
+import { BinaryReader, BinaryWriter } from '../../binary.js';
+import { type JsonSafe } from '../../json-safe.js';
+/**
+ * `Any` contains an arbitrary serialized protocol buffer message along with a
+ * URL that describes the type of the serialized message.
+ *
+ * Protobuf library provides support to pack/unpack Any values in the form
+ * of utility functions or additional generated methods of the Any type.
+ *
+ * Example 1: Pack and unpack a message in C++.
+ *
+ *     Foo foo = ...;
+ *     Any any;
+ *     any.PackFrom(foo);
+ *     ...
+ *     if (any.UnpackTo(&foo)) {
+ *       ...
+ *     }
+ *
+ * Example 2: Pack and unpack a message in Java.
+ *
+ *     Foo foo = ...;
+ *     Any any = Any.pack(foo);
+ *     ...
+ *     if (any.is(Foo.class)) {
+ *       foo = any.unpack(Foo.class);
+ *     }
+ *
+ *  Example 3: Pack and unpack a message in Python.
+ *
+ *     foo = Foo(...)
+ *     any = Any()
+ *     any.Pack(foo)
+ *     ...
+ *     if any.Is(Foo.DESCRIPTOR):
+ *       any.Unpack(foo)
+ *       ...
+ *
+ *  Example 4: Pack and unpack a message in Go
+ *
+ *      foo := &pb.Foo{...}
+ *      any, err := anypb.New(foo)
+ *      if err != nil {
+ *        ...
+ *      }
+ *      ...
+ *      foo := &pb.Foo{}
+ *      if err := any.UnmarshalTo(foo); err != nil {
+ *        ...
+ *      }
+ *
+ * The pack methods provided by protobuf library will by default use
+ * 'type.googleapis.com/full.type.name' as the type URL and the unpack
+ * methods only use the fully qualified type name after the last '/'
+ * in the type URL, for example "foo.bar.com/x/y.z" will yield type
+ * name "y.z".
+ *
+ *
+ * JSON
+ * ====
+ * The JSON representation of an `Any` value uses the regular
+ * representation of the deserialized, embedded message, with an
+ * additional field `@type` which contains the type URL. Example:
+ *
+ *     package google.profile;
+ *     message Person {
+ *       string first_name = 1;
+ *       string last_name = 2;
+ *     }
+ *
+ *     {
+ *       "@type": "type.googleapis.com/google.profile.Person",
+ *       "firstName": <string>,
+ *       "lastName": <string>
+ *     }
+ *
+ * If the embedded message type is well-known and has a custom JSON
+ * representation, that representation will be embedded adding a field
+ * `value` which holds the custom JSON in addition to the `@type`
+ * field. Example (for message [google.protobuf.Duration][]):
+ *
+ *     {
+ *       "@type": "type.googleapis.com/google.protobuf.Duration",
+ *       "value": "1.212s"
+ *     }
+ */
+export interface Any {
+    $typeUrl?: '/google.protobuf.Any' | string;
+    /**
+     * A URL/resource name that uniquely identifies the type of the serialized
+     * protocol buffer message. This string must contain at least
+     * one "/" character. The last segment of the URL's path must represent
+     * the fully qualified name of the type (as in
+     * `path/google.protobuf.Duration`). The name should be in a canonical form
+     * (e.g., leading "." is not accepted).
+     *
+     * In practice, teams usually precompile into the binary all types that they
+     * expect it to use in the context of Any. However, for URLs which use the
+     * scheme `http`, `https`, or no scheme, one can optionally set up a type
+     * server that maps type URLs to message definitions as follows:
+     *
+     * * If no scheme is provided, `https` is assumed.
+     * * An HTTP GET on the URL must yield a [google.protobuf.Type][]
+     *   value in binary format, or produce an error.
+     * * Applications are allowed to cache lookup results based on the
+     *   URL, or have them precompiled into a binary to avoid any
+     *   lookup. Therefore, binary compatibility needs to be preserved
+     *   on changes to types. (Use versioned type names to manage
+     *   breaking changes.)
+     *
+     * Note: this functionality is not currently available in the official
+     * protobuf release, and it is not used for type URLs beginning with
+     * type.googleapis.com.
+     *
+     * Schemes other than `http`, `https` (or the empty scheme) might be
+     * used with implementation specific semantics.
+     */
+    typeUrl: string;
+    /** Must be a valid serialized protocol buffer of the above specified type. */
+    value: Uint8Array;
+}
+export interface AnyProtoMsg {
+    typeUrl: '/google.protobuf.Any';
+    value: Uint8Array;
+}
+/**
+ * `Any` contains an arbitrary serialized protocol buffer message along with a
+ * URL that describes the type of the serialized message.
+ *
+ * Protobuf library provides support to pack/unpack Any values in the form
+ * of utility functions or additional generated methods of the Any type.
+ *
+ * Example 1: Pack and unpack a message in C++.
+ *
+ *     Foo foo = ...;
+ *     Any any;
+ *     any.PackFrom(foo);
+ *     ...
+ *     if (any.UnpackTo(&foo)) {
+ *       ...
+ *     }
+ *
+ * Example 2: Pack and unpack a message in Java.
+ *
+ *     Foo foo = ...;
+ *     Any any = Any.pack(foo);
+ *     ...
+ *     if (any.is(Foo.class)) {
+ *       foo = any.unpack(Foo.class);
+ *     }
+ *
+ *  Example 3: Pack and unpack a message in Python.
+ *
+ *     foo = Foo(...)
+ *     any = Any()
+ *     any.Pack(foo)
+ *     ...
+ *     if any.Is(Foo.DESCRIPTOR):
+ *       any.Unpack(foo)
+ *       ...
+ *
+ *  Example 4: Pack and unpack a message in Go
+ *
+ *      foo := &pb.Foo{...}
+ *      any, err := anypb.New(foo)
+ *      if err != nil {
+ *        ...
+ *      }
+ *      ...
+ *      foo := &pb.Foo{}
+ *      if err := any.UnmarshalTo(foo); err != nil {
+ *        ...
+ *      }
+ *
+ * The pack methods provided by protobuf library will by default use
+ * 'type.googleapis.com/full.type.name' as the type URL and the unpack
+ * methods only use the fully qualified type name after the last '/'
+ * in the type URL, for example "foo.bar.com/x/y.z" will yield type
+ * name "y.z".
+ *
+ *
+ * JSON
+ * ====
+ * The JSON representation of an `Any` value uses the regular
+ * representation of the deserialized, embedded message, with an
+ * additional field `@type` which contains the type URL. Example:
+ *
+ *     package google.profile;
+ *     message Person {
+ *       string first_name = 1;
+ *       string last_name = 2;
+ *     }
+ *
+ *     {
+ *       "@type": "type.googleapis.com/google.profile.Person",
+ *       "firstName": <string>,
+ *       "lastName": <string>
+ *     }
+ *
+ * If the embedded message type is well-known and has a custom JSON
+ * representation, that representation will be embedded adding a field
+ * `value` which holds the custom JSON in addition to the `@type`
+ * field. Example (for message [google.protobuf.Duration][]):
+ *
+ *     {
+ *       "@type": "type.googleapis.com/google.protobuf.Duration",
+ *       "value": "1.212s"
+ *     }
+ */
+export interface AnySDKType {
+    $typeUrl?: '/google.protobuf.Any' | string;
+    type_url: string;
+    value: Uint8Array;
+}
+export declare const Any: {
+    typeUrl: "/google.protobuf.Any";
+    encode(message: Any, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Any;
+    fromJSON(object: any): Any;
+    toJSON(message: Any): JsonSafe<Any>;
+    fromPartial(object: Partial<Any>): Any;
+    fromProtoMsg(message: AnyProtoMsg): Any;
+    toProto(message: Any): Uint8Array;
+    toProtoMsg(message: Any): AnyProtoMsg;
+};
+//# sourceMappingURL=any.d.ts.map

package/dist/codegen/google/protobuf/any.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"any.d.ts","sourceRoot":"","sources":["../../../../src/codegen/google/protobuf/any.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAI7D,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG;AACH,MAAM,WAAW,GAAG;IAClB,QAAQ,CAAC,EAAE,sBAAsB,GAAG,MAAM,CAAC;IAC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB,8EAA8E;IAC9E,KAAK,EAAE,UAAU,CAAC;CACnB;AACD,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,sBAAsB,CAAC;IAChC,KAAK,EAAE,UAAU,CAAC;CACnB;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,sBAAsB,GAAG,MAAM,CAAC;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,UAAU,CAAC;CACnB;AAQD,eAAO,MAAM,GAAG;;oBAGH,GAAG,WACJ,YAAY,GACnB,YAAY;kBASD,YAAY,GAAG,UAAU,WAAW,MAAM,GAAG,GAAG;qBAqB7C,GAAG,GAAG,GAAG;oBAQV,GAAG,GAAG,QAAQ,CAAC,GAAG,CAAC;wBASf,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG;0BAMhB,WAAW,GAAG,GAAG;qBAGtB,GAAG,GAAG,UAAU;wBAGb,GAAG,GAAG,WAAW;CAMtC,CAAC"}