@agoric/client-utils 0.2.0 → 0.2.1-upgrade-23-dev-bd79330.0.bd79330

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

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

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

@@ -1 +0,0 @@
-{"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

@@ -1,17 +0,0 @@
-//@ts-nocheck
-import * as _132 from './protobuf/any.js';
-import * as _133 from './protobuf/descriptor.js';
-import * as _134 from './protobuf/duration.js';
-import * as _135 from './protobuf/empty.js';
-import * as _136 from './protobuf/timestamp.js';
-export var google;
-(function (google) {
-    google.protobuf = {
-        ..._132,
-        ..._133,
-        ..._134,
-        ..._135,
-        ..._136,
-    };
-})(google || (google = {}));
-//# sourceMappingURL=bundle.js.map

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

@@ -1 +0,0 @@
-{"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

@@ -1,226 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}