@manifest-network/manifestjs 2.1.0

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

@@ -0,0 +1,566 @@
+import * as _92 from "./protobuf/any";
+import * as _93 from "./protobuf/descriptor";
+import * as _94 from "./protobuf/duration";
+import * as _95 from "./protobuf/empty";
+import * as _96 from "./protobuf/timestamp";
+export declare namespace google {
+    const protobuf: {
+        Timestamp: {
+            typeUrl: string;
+            is(o: any): o is _96.Timestamp;
+            isSDK(o: any): o is _96.TimestampSDKType;
+            isAmino(o: any): o is _96.TimestampAmino;
+            encode(message: _96.Timestamp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _96.Timestamp;
+            fromJSON(object: any): _96.Timestamp;
+            toJSON(message: _96.Timestamp): import("..").JsonSafe<_96.Timestamp>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_96.Timestamp>, I>>(object: I): _96.Timestamp;
+            fromAmino(object: _96.TimestampAmino): _96.Timestamp;
+            toAmino(message: _96.Timestamp): _96.TimestampAmino;
+            fromAminoMsg(object: _96.TimestampAminoMsg): _96.Timestamp;
+            fromProtoMsg(message: _96.TimestampProtoMsg): _96.Timestamp;
+            toProto(message: _96.Timestamp): Uint8Array;
+            toProtoMsg(message: _96.Timestamp): _96.TimestampProtoMsg;
+        };
+        Empty: {
+            typeUrl: string;
+            is(o: any): o is _95.Empty;
+            isSDK(o: any): o is _95.EmptySDKType;
+            isAmino(o: any): o is _95.EmptyAmino;
+            encode(_: _95.Empty, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _95.Empty;
+            fromJSON(_: any): _95.Empty;
+            toJSON(_: _95.Empty): import("..").JsonSafe<_95.Empty>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_95.Empty>, I>>(_: I): _95.Empty;
+            fromAmino(_: _95.EmptyAmino): _95.Empty;
+            toAmino(_: _95.Empty): _95.EmptyAmino;
+            fromAminoMsg(object: _95.EmptyAminoMsg): _95.Empty;
+            fromProtoMsg(message: _95.EmptyProtoMsg): _95.Empty;
+            toProto(message: _95.Empty): Uint8Array;
+            toProtoMsg(message: _95.Empty): _95.EmptyProtoMsg;
+        };
+        Duration: {
+            typeUrl: string;
+            is(o: any): o is _94.Duration;
+            isSDK(o: any): o is _94.DurationSDKType;
+            isAmino(o: any): o is _94.DurationAmino;
+            encode(message: _94.Duration, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _94.Duration;
+            fromJSON(object: any): _94.Duration;
+            toJSON(message: _94.Duration): import("..").JsonSafe<_94.Duration>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_94.Duration>, I>>(object: I): _94.Duration;
+            fromAmino(object: _94.DurationAmino): _94.Duration;
+            toAmino(message: _94.Duration): _94.DurationAmino;
+            fromAminoMsg(object: _94.DurationAminoMsg): _94.Duration;
+            fromProtoMsg(message: _94.DurationProtoMsg): _94.Duration;
+            toProto(message: _94.Duration): Uint8Array;
+            toProtoMsg(message: _94.Duration): _94.DurationProtoMsg;
+        };
+        fieldDescriptorProto_TypeFromJSON(object: any): _93.FieldDescriptorProto_Type;
+        fieldDescriptorProto_TypeToJSON(object: _93.FieldDescriptorProto_Type): string;
+        fieldDescriptorProto_LabelFromJSON(object: any): _93.FieldDescriptorProto_Label;
+        fieldDescriptorProto_LabelToJSON(object: _93.FieldDescriptorProto_Label): string;
+        fileOptions_OptimizeModeFromJSON(object: any): _93.FileOptions_OptimizeMode;
+        fileOptions_OptimizeModeToJSON(object: _93.FileOptions_OptimizeMode): string;
+        fieldOptions_CTypeFromJSON(object: any): _93.FieldOptions_CType;
+        fieldOptions_CTypeToJSON(object: _93.FieldOptions_CType): string;
+        fieldOptions_JSTypeFromJSON(object: any): _93.FieldOptions_JSType;
+        fieldOptions_JSTypeToJSON(object: _93.FieldOptions_JSType): string;
+        methodOptions_IdempotencyLevelFromJSON(object: any): _93.MethodOptions_IdempotencyLevel;
+        methodOptions_IdempotencyLevelToJSON(object: _93.MethodOptions_IdempotencyLevel): string;
+        FieldDescriptorProto_Type: typeof _93.FieldDescriptorProto_Type;
+        FieldDescriptorProto_TypeSDKType: typeof _93.FieldDescriptorProto_Type;
+        FieldDescriptorProto_TypeAmino: typeof _93.FieldDescriptorProto_Type;
+        FieldDescriptorProto_Label: typeof _93.FieldDescriptorProto_Label;
+        FieldDescriptorProto_LabelSDKType: typeof _93.FieldDescriptorProto_Label;
+        FieldDescriptorProto_LabelAmino: typeof _93.FieldDescriptorProto_Label;
+        FileOptions_OptimizeMode: typeof _93.FileOptions_OptimizeMode;
+        FileOptions_OptimizeModeSDKType: typeof _93.FileOptions_OptimizeMode;
+        FileOptions_OptimizeModeAmino: typeof _93.FileOptions_OptimizeMode;
+        FieldOptions_CType: typeof _93.FieldOptions_CType;
+        FieldOptions_CTypeSDKType: typeof _93.FieldOptions_CType;
+        FieldOptions_CTypeAmino: typeof _93.FieldOptions_CType;
+        FieldOptions_JSType: typeof _93.FieldOptions_JSType;
+        FieldOptions_JSTypeSDKType: typeof _93.FieldOptions_JSType;
+        FieldOptions_JSTypeAmino: typeof _93.FieldOptions_JSType;
+        MethodOptions_IdempotencyLevel: typeof _93.MethodOptions_IdempotencyLevel;
+        MethodOptions_IdempotencyLevelSDKType: typeof _93.MethodOptions_IdempotencyLevel;
+        MethodOptions_IdempotencyLevelAmino: typeof _93.MethodOptions_IdempotencyLevel;
+        FileDescriptorSet: {
+            typeUrl: string;
+            is(o: any): o is _93.FileDescriptorSet;
+            isSDK(o: any): o is _93.FileDescriptorSetSDKType;
+            isAmino(o: any): o is _93.FileDescriptorSetAmino;
+            encode(message: _93.FileDescriptorSet, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.FileDescriptorSet;
+            fromJSON(object: any): _93.FileDescriptorSet;
+            toJSON(message: _93.FileDescriptorSet): import("..").JsonSafe<_93.FileDescriptorSet>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.FileDescriptorSet>, I>>(object: I): _93.FileDescriptorSet;
+            fromAmino(object: _93.FileDescriptorSetAmino): _93.FileDescriptorSet;
+            toAmino(message: _93.FileDescriptorSet): _93.FileDescriptorSetAmino;
+            fromAminoMsg(object: _93.FileDescriptorSetAminoMsg): _93.FileDescriptorSet;
+            fromProtoMsg(message: _93.FileDescriptorSetProtoMsg): _93.FileDescriptorSet;
+            toProto(message: _93.FileDescriptorSet): Uint8Array;
+            toProtoMsg(message: _93.FileDescriptorSet): _93.FileDescriptorSetProtoMsg;
+        };
+        FileDescriptorProto: {
+            typeUrl: string;
+            is(o: any): o is _93.FileDescriptorProto;
+            isSDK(o: any): o is _93.FileDescriptorProtoSDKType;
+            isAmino(o: any): o is _93.FileDescriptorProtoAmino;
+            encode(message: _93.FileDescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.FileDescriptorProto;
+            fromJSON(object: any): _93.FileDescriptorProto;
+            toJSON(message: _93.FileDescriptorProto): import("..").JsonSafe<_93.FileDescriptorProto>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.FileDescriptorProto>, I>>(object: I): _93.FileDescriptorProto;
+            fromAmino(object: _93.FileDescriptorProtoAmino): _93.FileDescriptorProto;
+            toAmino(message: _93.FileDescriptorProto): _93.FileDescriptorProtoAmino;
+            fromAminoMsg(object: _93.FileDescriptorProtoAminoMsg): _93.FileDescriptorProto;
+            fromProtoMsg(message: _93.FileDescriptorProtoProtoMsg): _93.FileDescriptorProto;
+            toProto(message: _93.FileDescriptorProto): Uint8Array;
+            toProtoMsg(message: _93.FileDescriptorProto): _93.FileDescriptorProtoProtoMsg;
+        };
+        DescriptorProto: {
+            typeUrl: string;
+            is(o: any): o is _93.DescriptorProto;
+            isSDK(o: any): o is _93.DescriptorProtoSDKType;
+            isAmino(o: any): o is _93.DescriptorProtoAmino;
+            encode(message: _93.DescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.DescriptorProto;
+            fromJSON(object: any): _93.DescriptorProto;
+            toJSON(message: _93.DescriptorProto): import("..").JsonSafe<_93.DescriptorProto>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.DescriptorProto>, I>>(object: I): _93.DescriptorProto;
+            fromAmino(object: _93.DescriptorProtoAmino): _93.DescriptorProto;
+            toAmino(message: _93.DescriptorProto): _93.DescriptorProtoAmino;
+            fromAminoMsg(object: _93.DescriptorProtoAminoMsg): _93.DescriptorProto;
+            fromProtoMsg(message: _93.DescriptorProtoProtoMsg): _93.DescriptorProto;
+            toProto(message: _93.DescriptorProto): Uint8Array;
+            toProtoMsg(message: _93.DescriptorProto): _93.DescriptorProtoProtoMsg;
+        };
+        DescriptorProto_ExtensionRange: {
+            typeUrl: string;
+            is(o: any): o is _93.DescriptorProto_ExtensionRange;
+            isSDK(o: any): o is _93.DescriptorProto_ExtensionRangeSDKType;
+            isAmino(o: any): o is _93.DescriptorProto_ExtensionRangeAmino;
+            encode(message: _93.DescriptorProto_ExtensionRange, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.DescriptorProto_ExtensionRange;
+            fromJSON(object: any): _93.DescriptorProto_ExtensionRange;
+            toJSON(message: _93.DescriptorProto_ExtensionRange): import("..").JsonSafe<_93.DescriptorProto_ExtensionRange>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.DescriptorProto_ExtensionRange>, I>>(object: I): _93.DescriptorProto_ExtensionRange;
+            fromAmino(object: _93.DescriptorProto_ExtensionRangeAmino): _93.DescriptorProto_ExtensionRange;
+            toAmino(message: _93.DescriptorProto_ExtensionRange): _93.DescriptorProto_ExtensionRangeAmino;
+            fromAminoMsg(object: _93.DescriptorProto_ExtensionRangeAminoMsg): _93.DescriptorProto_ExtensionRange;
+            fromProtoMsg(message: _93.DescriptorProto_ExtensionRangeProtoMsg): _93.DescriptorProto_ExtensionRange;
+            toProto(message: _93.DescriptorProto_ExtensionRange): Uint8Array;
+            toProtoMsg(message: _93.DescriptorProto_ExtensionRange): _93.DescriptorProto_ExtensionRangeProtoMsg;
+        };
+        DescriptorProto_ReservedRange: {
+            typeUrl: string;
+            is(o: any): o is _93.DescriptorProto_ReservedRange;
+            isSDK(o: any): o is _93.DescriptorProto_ReservedRangeSDKType;
+            isAmino(o: any): o is _93.DescriptorProto_ReservedRangeAmino;
+            encode(message: _93.DescriptorProto_ReservedRange, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.DescriptorProto_ReservedRange;
+            fromJSON(object: any): _93.DescriptorProto_ReservedRange;
+            toJSON(message: _93.DescriptorProto_ReservedRange): import("..").JsonSafe<_93.DescriptorProto_ReservedRange>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.DescriptorProto_ReservedRange>, I>>(object: I): _93.DescriptorProto_ReservedRange;
+            fromAmino(object: _93.DescriptorProto_ReservedRangeAmino): _93.DescriptorProto_ReservedRange;
+            toAmino(message: _93.DescriptorProto_ReservedRange): _93.DescriptorProto_ReservedRangeAmino;
+            fromAminoMsg(object: _93.DescriptorProto_ReservedRangeAminoMsg): _93.DescriptorProto_ReservedRange;
+            fromProtoMsg(message: _93.DescriptorProto_ReservedRangeProtoMsg): _93.DescriptorProto_ReservedRange;
+            toProto(message: _93.DescriptorProto_ReservedRange): Uint8Array;
+            toProtoMsg(message: _93.DescriptorProto_ReservedRange): _93.DescriptorProto_ReservedRangeProtoMsg;
+        };
+        ExtensionRangeOptions: {
+            typeUrl: string;
+            is(o: any): o is _93.ExtensionRangeOptions;
+            isSDK(o: any): o is _93.ExtensionRangeOptionsSDKType;
+            isAmino(o: any): o is _93.ExtensionRangeOptionsAmino;
+            encode(message: _93.ExtensionRangeOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.ExtensionRangeOptions;
+            fromJSON(object: any): _93.ExtensionRangeOptions;
+            toJSON(message: _93.ExtensionRangeOptions): import("..").JsonSafe<_93.ExtensionRangeOptions>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.ExtensionRangeOptions>, I>>(object: I): _93.ExtensionRangeOptions;
+            fromAmino(object: _93.ExtensionRangeOptionsAmino): _93.ExtensionRangeOptions;
+            toAmino(message: _93.ExtensionRangeOptions): _93.ExtensionRangeOptionsAmino;
+            fromAminoMsg(object: _93.ExtensionRangeOptionsAminoMsg): _93.ExtensionRangeOptions;
+            fromProtoMsg(message: _93.ExtensionRangeOptionsProtoMsg): _93.ExtensionRangeOptions;
+            toProto(message: _93.ExtensionRangeOptions): Uint8Array;
+            toProtoMsg(message: _93.ExtensionRangeOptions): _93.ExtensionRangeOptionsProtoMsg;
+        };
+        FieldDescriptorProto: {
+            typeUrl: string;
+            is(o: any): o is _93.FieldDescriptorProto;
+            isSDK(o: any): o is _93.FieldDescriptorProtoSDKType;
+            isAmino(o: any): o is _93.FieldDescriptorProtoAmino;
+            encode(message: _93.FieldDescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.FieldDescriptorProto;
+            fromJSON(object: any): _93.FieldDescriptorProto;
+            toJSON(message: _93.FieldDescriptorProto): import("..").JsonSafe<_93.FieldDescriptorProto>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.FieldDescriptorProto>, I>>(object: I): _93.FieldDescriptorProto;
+            fromAmino(object: _93.FieldDescriptorProtoAmino): _93.FieldDescriptorProto;
+            toAmino(message: _93.FieldDescriptorProto): _93.FieldDescriptorProtoAmino;
+            fromAminoMsg(object: _93.FieldDescriptorProtoAminoMsg): _93.FieldDescriptorProto;
+            fromProtoMsg(message: _93.FieldDescriptorProtoProtoMsg): _93.FieldDescriptorProto;
+            toProto(message: _93.FieldDescriptorProto): Uint8Array;
+            toProtoMsg(message: _93.FieldDescriptorProto): _93.FieldDescriptorProtoProtoMsg;
+        };
+        OneofDescriptorProto: {
+            typeUrl: string;
+            is(o: any): o is _93.OneofDescriptorProto;
+            isSDK(o: any): o is _93.OneofDescriptorProtoSDKType;
+            isAmino(o: any): o is _93.OneofDescriptorProtoAmino;
+            encode(message: _93.OneofDescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.OneofDescriptorProto;
+            fromJSON(object: any): _93.OneofDescriptorProto;
+            toJSON(message: _93.OneofDescriptorProto): import("..").JsonSafe<_93.OneofDescriptorProto>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.OneofDescriptorProto>, I>>(object: I): _93.OneofDescriptorProto;
+            fromAmino(object: _93.OneofDescriptorProtoAmino): _93.OneofDescriptorProto;
+            toAmino(message: _93.OneofDescriptorProto): _93.OneofDescriptorProtoAmino;
+            fromAminoMsg(object: _93.OneofDescriptorProtoAminoMsg): _93.OneofDescriptorProto;
+            fromProtoMsg(message: _93.OneofDescriptorProtoProtoMsg): _93.OneofDescriptorProto;
+            toProto(message: _93.OneofDescriptorProto): Uint8Array;
+            toProtoMsg(message: _93.OneofDescriptorProto): _93.OneofDescriptorProtoProtoMsg;
+        };
+        EnumDescriptorProto: {
+            typeUrl: string;
+            is(o: any): o is _93.EnumDescriptorProto;
+            isSDK(o: any): o is _93.EnumDescriptorProtoSDKType;
+            isAmino(o: any): o is _93.EnumDescriptorProtoAmino;
+            encode(message: _93.EnumDescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.EnumDescriptorProto;
+            fromJSON(object: any): _93.EnumDescriptorProto;
+            toJSON(message: _93.EnumDescriptorProto): import("..").JsonSafe<_93.EnumDescriptorProto>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.EnumDescriptorProto>, I>>(object: I): _93.EnumDescriptorProto;
+            fromAmino(object: _93.EnumDescriptorProtoAmino): _93.EnumDescriptorProto;
+            toAmino(message: _93.EnumDescriptorProto): _93.EnumDescriptorProtoAmino;
+            fromAminoMsg(object: _93.EnumDescriptorProtoAminoMsg): _93.EnumDescriptorProto;
+            fromProtoMsg(message: _93.EnumDescriptorProtoProtoMsg): _93.EnumDescriptorProto;
+            toProto(message: _93.EnumDescriptorProto): Uint8Array;
+            toProtoMsg(message: _93.EnumDescriptorProto): _93.EnumDescriptorProtoProtoMsg;
+        };
+        EnumDescriptorProto_EnumReservedRange: {
+            typeUrl: string;
+            is(o: any): o is _93.EnumDescriptorProto_EnumReservedRange;
+            isSDK(o: any): o is _93.EnumDescriptorProto_EnumReservedRangeSDKType;
+            isAmino(o: any): o is _93.EnumDescriptorProto_EnumReservedRangeAmino;
+            encode(message: _93.EnumDescriptorProto_EnumReservedRange, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.EnumDescriptorProto_EnumReservedRange;
+            fromJSON(object: any): _93.EnumDescriptorProto_EnumReservedRange;
+            toJSON(message: _93.EnumDescriptorProto_EnumReservedRange): import("..").JsonSafe<_93.EnumDescriptorProto_EnumReservedRange>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.EnumDescriptorProto_EnumReservedRange>, I>>(object: I): _93.EnumDescriptorProto_EnumReservedRange;
+            fromAmino(object: _93.EnumDescriptorProto_EnumReservedRangeAmino): _93.EnumDescriptorProto_EnumReservedRange;
+            toAmino(message: _93.EnumDescriptorProto_EnumReservedRange): _93.EnumDescriptorProto_EnumReservedRangeAmino;
+            fromAminoMsg(object: _93.EnumDescriptorProto_EnumReservedRangeAminoMsg): _93.EnumDescriptorProto_EnumReservedRange;
+            fromProtoMsg(message: _93.EnumDescriptorProto_EnumReservedRangeProtoMsg): _93.EnumDescriptorProto_EnumReservedRange;
+            toProto(message: _93.EnumDescriptorProto_EnumReservedRange): Uint8Array;
+            toProtoMsg(message: _93.EnumDescriptorProto_EnumReservedRange): _93.EnumDescriptorProto_EnumReservedRangeProtoMsg;
+        };
+        EnumValueDescriptorProto: {
+            typeUrl: string;
+            is(o: any): o is _93.EnumValueDescriptorProto;
+            isSDK(o: any): o is _93.EnumValueDescriptorProtoSDKType;
+            isAmino(o: any): o is _93.EnumValueDescriptorProtoAmino;
+            encode(message: _93.EnumValueDescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.EnumValueDescriptorProto;
+            fromJSON(object: any): _93.EnumValueDescriptorProto;
+            toJSON(message: _93.EnumValueDescriptorProto): import("..").JsonSafe<_93.EnumValueDescriptorProto>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.EnumValueDescriptorProto>, I>>(object: I): _93.EnumValueDescriptorProto;
+            fromAmino(object: _93.EnumValueDescriptorProtoAmino): _93.EnumValueDescriptorProto;
+            toAmino(message: _93.EnumValueDescriptorProto): _93.EnumValueDescriptorProtoAmino;
+            fromAminoMsg(object: _93.EnumValueDescriptorProtoAminoMsg): _93.EnumValueDescriptorProto;
+            fromProtoMsg(message: _93.EnumValueDescriptorProtoProtoMsg): _93.EnumValueDescriptorProto;
+            toProto(message: _93.EnumValueDescriptorProto): Uint8Array;
+            toProtoMsg(message: _93.EnumValueDescriptorProto): _93.EnumValueDescriptorProtoProtoMsg;
+        };
+        ServiceDescriptorProto: {
+            typeUrl: string;
+            is(o: any): o is _93.ServiceDescriptorProto;
+            isSDK(o: any): o is _93.ServiceDescriptorProtoSDKType;
+            isAmino(o: any): o is _93.ServiceDescriptorProtoAmino;
+            encode(message: _93.ServiceDescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.ServiceDescriptorProto;
+            fromJSON(object: any): _93.ServiceDescriptorProto;
+            toJSON(message: _93.ServiceDescriptorProto): import("..").JsonSafe<_93.ServiceDescriptorProto>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.ServiceDescriptorProto>, I>>(object: I): _93.ServiceDescriptorProto;
+            fromAmino(object: _93.ServiceDescriptorProtoAmino): _93.ServiceDescriptorProto;
+            toAmino(message: _93.ServiceDescriptorProto): _93.ServiceDescriptorProtoAmino;
+            fromAminoMsg(object: _93.ServiceDescriptorProtoAminoMsg): _93.ServiceDescriptorProto;
+            fromProtoMsg(message: _93.ServiceDescriptorProtoProtoMsg): _93.ServiceDescriptorProto;
+            toProto(message: _93.ServiceDescriptorProto): Uint8Array;
+            toProtoMsg(message: _93.ServiceDescriptorProto): _93.ServiceDescriptorProtoProtoMsg;
+        };
+        MethodDescriptorProto: {
+            typeUrl: string;
+            is(o: any): o is _93.MethodDescriptorProto;
+            isSDK(o: any): o is _93.MethodDescriptorProtoSDKType;
+            isAmino(o: any): o is _93.MethodDescriptorProtoAmino;
+            encode(message: _93.MethodDescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.MethodDescriptorProto;
+            fromJSON(object: any): _93.MethodDescriptorProto;
+            toJSON(message: _93.MethodDescriptorProto): import("..").JsonSafe<_93.MethodDescriptorProto>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.MethodDescriptorProto>, I>>(object: I): _93.MethodDescriptorProto;
+            fromAmino(object: _93.MethodDescriptorProtoAmino): _93.MethodDescriptorProto;
+            toAmino(message: _93.MethodDescriptorProto): _93.MethodDescriptorProtoAmino;
+            fromAminoMsg(object: _93.MethodDescriptorProtoAminoMsg): _93.MethodDescriptorProto;
+            fromProtoMsg(message: _93.MethodDescriptorProtoProtoMsg): _93.MethodDescriptorProto;
+            toProto(message: _93.MethodDescriptorProto): Uint8Array;
+            toProtoMsg(message: _93.MethodDescriptorProto): _93.MethodDescriptorProtoProtoMsg;
+        };
+        FileOptions: {
+            typeUrl: string;
+            is(o: any): o is _93.FileOptions;
+            isSDK(o: any): o is _93.FileOptionsSDKType;
+            isAmino(o: any): o is _93.FileOptionsAmino;
+            encode(message: _93.FileOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.FileOptions;
+            fromJSON(object: any): _93.FileOptions;
+            toJSON(message: _93.FileOptions): import("..").JsonSafe<_93.FileOptions>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.FileOptions>, I>>(object: I): _93.FileOptions;
+            fromAmino(object: _93.FileOptionsAmino): _93.FileOptions;
+            toAmino(message: _93.FileOptions): _93.FileOptionsAmino;
+            fromAminoMsg(object: _93.FileOptionsAminoMsg): _93.FileOptions;
+            fromProtoMsg(message: _93.FileOptionsProtoMsg): _93.FileOptions;
+            toProto(message: _93.FileOptions): Uint8Array;
+            toProtoMsg(message: _93.FileOptions): _93.FileOptionsProtoMsg;
+        };
+        MessageOptions: {
+            typeUrl: string;
+            is(o: any): o is _93.MessageOptions;
+            isSDK(o: any): o is _93.MessageOptionsSDKType;
+            isAmino(o: any): o is _93.MessageOptionsAmino;
+            encode(message: _93.MessageOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.MessageOptions;
+            fromJSON(object: any): _93.MessageOptions;
+            toJSON(message: _93.MessageOptions): import("..").JsonSafe<_93.MessageOptions>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.MessageOptions>, I>>(object: I): _93.MessageOptions;
+            fromAmino(object: _93.MessageOptionsAmino): _93.MessageOptions;
+            toAmino(message: _93.MessageOptions): _93.MessageOptionsAmino;
+            fromAminoMsg(object: _93.MessageOptionsAminoMsg): _93.MessageOptions;
+            fromProtoMsg(message: _93.MessageOptionsProtoMsg): _93.MessageOptions;
+            toProto(message: _93.MessageOptions): Uint8Array;
+            toProtoMsg(message: _93.MessageOptions): _93.MessageOptionsProtoMsg;
+        };
+        FieldOptions: {
+            typeUrl: string;
+            is(o: any): o is _93.FieldOptions;
+            isSDK(o: any): o is _93.FieldOptionsSDKType;
+            isAmino(o: any): o is _93.FieldOptionsAmino;
+            encode(message: _93.FieldOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.FieldOptions;
+            fromJSON(object: any): _93.FieldOptions;
+            toJSON(message: _93.FieldOptions): import("..").JsonSafe<_93.FieldOptions>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.FieldOptions>, I>>(object: I): _93.FieldOptions;
+            fromAmino(object: _93.FieldOptionsAmino): _93.FieldOptions;
+            toAmino(message: _93.FieldOptions): _93.FieldOptionsAmino;
+            fromAminoMsg(object: _93.FieldOptionsAminoMsg): _93.FieldOptions;
+            fromProtoMsg(message: _93.FieldOptionsProtoMsg): _93.FieldOptions;
+            toProto(message: _93.FieldOptions): Uint8Array;
+            toProtoMsg(message: _93.FieldOptions): _93.FieldOptionsProtoMsg;
+        };
+        OneofOptions: {
+            typeUrl: string;
+            is(o: any): o is _93.OneofOptions;
+            isSDK(o: any): o is _93.OneofOptionsSDKType;
+            isAmino(o: any): o is _93.OneofOptionsAmino;
+            encode(message: _93.OneofOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.OneofOptions;
+            fromJSON(object: any): _93.OneofOptions;
+            toJSON(message: _93.OneofOptions): import("..").JsonSafe<_93.OneofOptions>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.OneofOptions>, I>>(object: I): _93.OneofOptions;
+            fromAmino(object: _93.OneofOptionsAmino): _93.OneofOptions;
+            toAmino(message: _93.OneofOptions): _93.OneofOptionsAmino;
+            fromAminoMsg(object: _93.OneofOptionsAminoMsg): _93.OneofOptions;
+            fromProtoMsg(message: _93.OneofOptionsProtoMsg): _93.OneofOptions;
+            toProto(message: _93.OneofOptions): Uint8Array;
+            toProtoMsg(message: _93.OneofOptions): _93.OneofOptionsProtoMsg;
+        };
+        EnumOptions: {
+            typeUrl: string;
+            is(o: any): o is _93.EnumOptions;
+            isSDK(o: any): o is _93.EnumOptionsSDKType;
+            isAmino(o: any): o is _93.EnumOptionsAmino;
+            encode(message: _93.EnumOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.EnumOptions;
+            fromJSON(object: any): _93.EnumOptions;
+            toJSON(message: _93.EnumOptions): import("..").JsonSafe<_93.EnumOptions>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.EnumOptions>, I>>(object: I): _93.EnumOptions;
+            fromAmino(object: _93.EnumOptionsAmino): _93.EnumOptions;
+            toAmino(message: _93.EnumOptions): _93.EnumOptionsAmino;
+            fromAminoMsg(object: _93.EnumOptionsAminoMsg): _93.EnumOptions;
+            fromProtoMsg(message: _93.EnumOptionsProtoMsg): _93.EnumOptions;
+            toProto(message: _93.EnumOptions): Uint8Array;
+            toProtoMsg(message: _93.EnumOptions): _93.EnumOptionsProtoMsg;
+        };
+        EnumValueOptions: {
+            typeUrl: string;
+            is(o: any): o is _93.EnumValueOptions;
+            isSDK(o: any): o is _93.EnumValueOptionsSDKType;
+            isAmino(o: any): o is _93.EnumValueOptionsAmino;
+            encode(message: _93.EnumValueOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.EnumValueOptions;
+            fromJSON(object: any): _93.EnumValueOptions;
+            toJSON(message: _93.EnumValueOptions): import("..").JsonSafe<_93.EnumValueOptions>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.EnumValueOptions>, I>>(object: I): _93.EnumValueOptions;
+            fromAmino(object: _93.EnumValueOptionsAmino): _93.EnumValueOptions;
+            toAmino(message: _93.EnumValueOptions): _93.EnumValueOptionsAmino;
+            fromAminoMsg(object: _93.EnumValueOptionsAminoMsg): _93.EnumValueOptions;
+            fromProtoMsg(message: _93.EnumValueOptionsProtoMsg): _93.EnumValueOptions;
+            toProto(message: _93.EnumValueOptions): Uint8Array;
+            toProtoMsg(message: _93.EnumValueOptions): _93.EnumValueOptionsProtoMsg;
+        };
+        ServiceOptions: {
+            typeUrl: string;
+            is(o: any): o is _93.ServiceOptions;
+            isSDK(o: any): o is _93.ServiceOptionsSDKType;
+            isAmino(o: any): o is _93.ServiceOptionsAmino;
+            encode(message: _93.ServiceOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.ServiceOptions;
+            fromJSON(object: any): _93.ServiceOptions;
+            toJSON(message: _93.ServiceOptions): import("..").JsonSafe<_93.ServiceOptions>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.ServiceOptions>, I>>(object: I): _93.ServiceOptions;
+            fromAmino(object: _93.ServiceOptionsAmino): _93.ServiceOptions;
+            toAmino(message: _93.ServiceOptions): _93.ServiceOptionsAmino;
+            fromAminoMsg(object: _93.ServiceOptionsAminoMsg): _93.ServiceOptions;
+            fromProtoMsg(message: _93.ServiceOptionsProtoMsg): _93.ServiceOptions;
+            toProto(message: _93.ServiceOptions): Uint8Array;
+            toProtoMsg(message: _93.ServiceOptions): _93.ServiceOptionsProtoMsg;
+        };
+        MethodOptions: {
+            typeUrl: string;
+            is(o: any): o is _93.MethodOptions;
+            isSDK(o: any): o is _93.MethodOptionsSDKType;
+            isAmino(o: any): o is _93.MethodOptionsAmino;
+            encode(message: _93.MethodOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.MethodOptions;
+            fromJSON(object: any): _93.MethodOptions;
+            toJSON(message: _93.MethodOptions): import("..").JsonSafe<_93.MethodOptions>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.MethodOptions>, I>>(object: I): _93.MethodOptions;
+            fromAmino(object: _93.MethodOptionsAmino): _93.MethodOptions;
+            toAmino(message: _93.MethodOptions): _93.MethodOptionsAmino;
+            fromAminoMsg(object: _93.MethodOptionsAminoMsg): _93.MethodOptions;
+            fromProtoMsg(message: _93.MethodOptionsProtoMsg): _93.MethodOptions;
+            toProto(message: _93.MethodOptions): Uint8Array;
+            toProtoMsg(message: _93.MethodOptions): _93.MethodOptionsProtoMsg;
+        };
+        UninterpretedOption: {
+            typeUrl: string;
+            is(o: any): o is _93.UninterpretedOption;
+            isSDK(o: any): o is _93.UninterpretedOptionSDKType;
+            isAmino(o: any): o is _93.UninterpretedOptionAmino;
+            encode(message: _93.UninterpretedOption, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.UninterpretedOption;
+            fromJSON(object: any): _93.UninterpretedOption;
+            toJSON(message: _93.UninterpretedOption): import("..").JsonSafe<_93.UninterpretedOption>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.UninterpretedOption>, I>>(object: I): _93.UninterpretedOption;
+            fromAmino(object: _93.UninterpretedOptionAmino): _93.UninterpretedOption;
+            toAmino(message: _93.UninterpretedOption): _93.UninterpretedOptionAmino;
+            fromAminoMsg(object: _93.UninterpretedOptionAminoMsg): _93.UninterpretedOption;
+            fromProtoMsg(message: _93.UninterpretedOptionProtoMsg): _93.UninterpretedOption;
+            toProto(message: _93.UninterpretedOption): Uint8Array;
+            toProtoMsg(message: _93.UninterpretedOption): _93.UninterpretedOptionProtoMsg;
+        };
+        UninterpretedOption_NamePart: {
+            typeUrl: string;
+            is(o: any): o is _93.UninterpretedOption_NamePart;
+            isSDK(o: any): o is _93.UninterpretedOption_NamePartSDKType;
+            isAmino(o: any): o is _93.UninterpretedOption_NamePartAmino;
+            encode(message: _93.UninterpretedOption_NamePart, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.UninterpretedOption_NamePart;
+            fromJSON(object: any): _93.UninterpretedOption_NamePart;
+            toJSON(message: _93.UninterpretedOption_NamePart): import("..").JsonSafe<_93.UninterpretedOption_NamePart>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.UninterpretedOption_NamePart>, I>>(object: I): _93.UninterpretedOption_NamePart;
+            fromAmino(object: _93.UninterpretedOption_NamePartAmino): _93.UninterpretedOption_NamePart;
+            toAmino(message: _93.UninterpretedOption_NamePart): _93.UninterpretedOption_NamePartAmino;
+            fromAminoMsg(object: _93.UninterpretedOption_NamePartAminoMsg): _93.UninterpretedOption_NamePart;
+            fromProtoMsg(message: _93.UninterpretedOption_NamePartProtoMsg): _93.UninterpretedOption_NamePart;
+            toProto(message: _93.UninterpretedOption_NamePart): Uint8Array;
+            toProtoMsg(message: _93.UninterpretedOption_NamePart): _93.UninterpretedOption_NamePartProtoMsg;
+        };
+        SourceCodeInfo: {
+            typeUrl: string;
+            is(o: any): o is _93.SourceCodeInfo;
+            isSDK(o: any): o is _93.SourceCodeInfoSDKType;
+            isAmino(o: any): o is _93.SourceCodeInfoAmino;
+            encode(message: _93.SourceCodeInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.SourceCodeInfo;
+            fromJSON(object: any): _93.SourceCodeInfo;
+            toJSON(message: _93.SourceCodeInfo): import("..").JsonSafe<_93.SourceCodeInfo>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.SourceCodeInfo>, I>>(object: I): _93.SourceCodeInfo;
+            fromAmino(object: _93.SourceCodeInfoAmino): _93.SourceCodeInfo;
+            toAmino(message: _93.SourceCodeInfo): _93.SourceCodeInfoAmino;
+            fromAminoMsg(object: _93.SourceCodeInfoAminoMsg): _93.SourceCodeInfo;
+            fromProtoMsg(message: _93.SourceCodeInfoProtoMsg): _93.SourceCodeInfo;
+            toProto(message: _93.SourceCodeInfo): Uint8Array;
+            toProtoMsg(message: _93.SourceCodeInfo): _93.SourceCodeInfoProtoMsg;
+        };
+        SourceCodeInfo_Location: {
+            typeUrl: string;
+            is(o: any): o is _93.SourceCodeInfo_Location;
+            isSDK(o: any): o is _93.SourceCodeInfo_LocationSDKType;
+            isAmino(o: any): o is _93.SourceCodeInfo_LocationAmino;
+            encode(message: _93.SourceCodeInfo_Location, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.SourceCodeInfo_Location;
+            fromJSON(object: any): _93.SourceCodeInfo_Location;
+            toJSON(message: _93.SourceCodeInfo_Location): import("..").JsonSafe<_93.SourceCodeInfo_Location>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.SourceCodeInfo_Location>, I>>(object: I): _93.SourceCodeInfo_Location;
+            fromAmino(object: _93.SourceCodeInfo_LocationAmino): _93.SourceCodeInfo_Location;
+            toAmino(message: _93.SourceCodeInfo_Location): _93.SourceCodeInfo_LocationAmino;
+            fromAminoMsg(object: _93.SourceCodeInfo_LocationAminoMsg): _93.SourceCodeInfo_Location;
+            fromProtoMsg(message: _93.SourceCodeInfo_LocationProtoMsg): _93.SourceCodeInfo_Location;
+            toProto(message: _93.SourceCodeInfo_Location): Uint8Array;
+            toProtoMsg(message: _93.SourceCodeInfo_Location): _93.SourceCodeInfo_LocationProtoMsg;
+        };
+        GeneratedCodeInfo: {
+            typeUrl: string;
+            is(o: any): o is _93.GeneratedCodeInfo;
+            isSDK(o: any): o is _93.GeneratedCodeInfoSDKType;
+            isAmino(o: any): o is _93.GeneratedCodeInfoAmino;
+            encode(message: _93.GeneratedCodeInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.GeneratedCodeInfo;
+            fromJSON(object: any): _93.GeneratedCodeInfo;
+            toJSON(message: _93.GeneratedCodeInfo): import("..").JsonSafe<_93.GeneratedCodeInfo>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.GeneratedCodeInfo>, I>>(object: I): _93.GeneratedCodeInfo;
+            fromAmino(object: _93.GeneratedCodeInfoAmino): _93.GeneratedCodeInfo;
+            toAmino(message: _93.GeneratedCodeInfo): _93.GeneratedCodeInfoAmino;
+            fromAminoMsg(object: _93.GeneratedCodeInfoAminoMsg): _93.GeneratedCodeInfo;
+            fromProtoMsg(message: _93.GeneratedCodeInfoProtoMsg): _93.GeneratedCodeInfo;
+            toProto(message: _93.GeneratedCodeInfo): Uint8Array;
+            toProtoMsg(message: _93.GeneratedCodeInfo): _93.GeneratedCodeInfoProtoMsg;
+        };
+        GeneratedCodeInfo_Annotation: {
+            typeUrl: string;
+            is(o: any): o is _93.GeneratedCodeInfo_Annotation;
+            isSDK(o: any): o is _93.GeneratedCodeInfo_AnnotationSDKType;
+            isAmino(o: any): o is _93.GeneratedCodeInfo_AnnotationAmino;
+            encode(message: _93.GeneratedCodeInfo_Annotation, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _93.GeneratedCodeInfo_Annotation;
+            fromJSON(object: any): _93.GeneratedCodeInfo_Annotation;
+            toJSON(message: _93.GeneratedCodeInfo_Annotation): import("..").JsonSafe<_93.GeneratedCodeInfo_Annotation>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_93.GeneratedCodeInfo_Annotation>, I>>(object: I): _93.GeneratedCodeInfo_Annotation;
+            fromAmino(object: _93.GeneratedCodeInfo_AnnotationAmino): _93.GeneratedCodeInfo_Annotation;
+            toAmino(message: _93.GeneratedCodeInfo_Annotation): _93.GeneratedCodeInfo_AnnotationAmino;
+            fromAminoMsg(object: _93.GeneratedCodeInfo_AnnotationAminoMsg): _93.GeneratedCodeInfo_Annotation;
+            fromProtoMsg(message: _93.GeneratedCodeInfo_AnnotationProtoMsg): _93.GeneratedCodeInfo_Annotation;
+            toProto(message: _93.GeneratedCodeInfo_Annotation): Uint8Array;
+            toProtoMsg(message: _93.GeneratedCodeInfo_Annotation): _93.GeneratedCodeInfo_AnnotationProtoMsg;
+        };
+        Any: {
+            typeUrl: string;
+            is(o: any): o is _92.Any;
+            isSDK(o: any): o is _92.AnySDKType;
+            isAmino(o: any): o is _92.AnyAmino;
+            encode(message: _92.Any, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _92.Any;
+            fromJSON(object: any): _92.Any;
+            toJSON(message: _92.Any): import("..").JsonSafe<_92.Any>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_92.Any>, I>>(object: I): _92.Any;
+            fromAmino(object: _92.AnyAmino): _92.Any;
+            toAmino(message: _92.Any): _92.AnyAmino;
+            fromAminoMsg(object: _92.AnyAminoMsg): _92.Any;
+            fromProtoMsg(message: _92.AnyProtoMsg): _92.Any;
+            toProto(message: _92.Any): Uint8Array;
+            toProtoMsg(message: _92.Any): _92.AnyProtoMsg;
+        };
+    };
+}

package/dist/codegen/google/bundle.js

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.google = void 0;
+const _92 = __importStar(require("./protobuf/any"));
+const _93 = __importStar(require("./protobuf/descriptor"));
+const _94 = __importStar(require("./protobuf/duration"));
+const _95 = __importStar(require("./protobuf/empty"));
+const _96 = __importStar(require("./protobuf/timestamp"));
+var google;
+(function (google) {
+    google.protobuf = {
+        ..._92,
+        ..._93,
+        ..._94,
+        ..._95,
+        ..._96
+    };
+})(google || (exports.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,oDAAsC;AACtC,2DAA6C;AAC7C,yDAA2C;AAC3C,sDAAwC;AACxC,0DAA4C;AAC5C,IAAiB,MAAM,CAQtB;AARD,WAAiB,MAAM;IACR,eAAQ,GAAG;QACtB,GAAG,GAAG;QACN,GAAG,GAAG;QACN,GAAG,GAAG;QACN,GAAG,GAAG;QACN,GAAG,GAAG;KACP,CAAC;AACJ,CAAC,EARgB,MAAM,sBAAN,MAAM,QAQtB"}

package/dist/codegen/google/bundle.mjs

@@ -0,0 +1,16 @@
+import * as _92 from "./protobuf/any";
+import * as _93 from "./protobuf/descriptor";
+import * as _94 from "./protobuf/duration";
+import * as _95 from "./protobuf/empty";
+import * as _96 from "./protobuf/timestamp";
+export var google;
+(function (google) {
+    google.protobuf = {
+        ..._92,
+        ..._93,
+        ..._94,
+        ..._95,
+        ..._96
+    };
+})(google || (google = {}));
+//# sourceMappingURL=bundle.js.map