import * as _72 from "./protobuf/any";
import * as _73 from "./protobuf/descriptor";
import * as _74 from "./protobuf/duration";
import * as _75 from "./protobuf/empty";
import * as _76 from "./protobuf/timestamp";
export declare namespace google {
    const protobuf: {
        Timestamp: {
            typeUrl: string;
            encode(message: _76.Timestamp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _76.Timestamp;
            fromPartial(object: Partial<_76.Timestamp>): _76.Timestamp;
            fromAmino(object: string): _76.Timestamp;
            toAmino(message: _76.Timestamp): string;
            fromAminoMsg(object: _76.TimestampAminoMsg): _76.Timestamp;
            fromProtoMsg(message: _76.TimestampProtoMsg): _76.Timestamp;
            toProto(message: _76.Timestamp): Uint8Array;
            toProtoMsg(message: _76.Timestamp): _76.TimestampProtoMsg;
        };
        Empty: {
            typeUrl: string;
            encode(_: _75.Empty, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _75.Empty;
            fromPartial(_: Partial<_75.Empty>): _75.Empty;
            fromAmino(_: _75.EmptyAmino): _75.Empty;
            toAmino(_: _75.Empty): _75.EmptyAmino;
            fromAminoMsg(object: _75.EmptyAminoMsg): _75.Empty;
            fromProtoMsg(message: _75.EmptyProtoMsg): _75.Empty;
            toProto(message: _75.Empty): Uint8Array;
            toProtoMsg(message: _75.Empty): _75.EmptyProtoMsg;
        };
        Duration: {
            typeUrl: string;
            encode(message: _74.Duration, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _74.Duration;
            fromPartial(object: Partial<_74.Duration>): _74.Duration;
            fromAmino(object: string): _74.Duration;
            toAmino(message: _74.Duration): string;
            fromAminoMsg(object: _74.DurationAminoMsg): _74.Duration;
            fromProtoMsg(message: _74.DurationProtoMsg): _74.Duration;
            toProto(message: _74.Duration): Uint8Array;
            toProtoMsg(message: _74.Duration): _74.DurationProtoMsg;
        };
        fieldDescriptorProto_TypeFromJSON(object: any): _73.FieldDescriptorProto_Type;
        fieldDescriptorProto_TypeToJSON(object: _73.FieldDescriptorProto_Type): string;
        fieldDescriptorProto_LabelFromJSON(object: any): _73.FieldDescriptorProto_Label;
        fieldDescriptorProto_LabelToJSON(object: _73.FieldDescriptorProto_Label): string;
        fileOptions_OptimizeModeFromJSON(object: any): _73.FileOptions_OptimizeMode;
        fileOptions_OptimizeModeToJSON(object: _73.FileOptions_OptimizeMode): string;
        fieldOptions_CTypeFromJSON(object: any): _73.FieldOptions_CType;
        fieldOptions_CTypeToJSON(object: _73.FieldOptions_CType): string;
        fieldOptions_JSTypeFromJSON(object: any): _73.FieldOptions_JSType;
        fieldOptions_JSTypeToJSON(object: _73.FieldOptions_JSType): string;
        methodOptions_IdempotencyLevelFromJSON(object: any): _73.MethodOptions_IdempotencyLevel;
        methodOptions_IdempotencyLevelToJSON(object: _73.MethodOptions_IdempotencyLevel): string;
        FieldDescriptorProto_Type: typeof _73.FieldDescriptorProto_Type;
        FieldDescriptorProto_TypeSDKType: typeof _73.FieldDescriptorProto_Type;
        FieldDescriptorProto_TypeAmino: typeof _73.FieldDescriptorProto_Type;
        FieldDescriptorProto_Label: typeof _73.FieldDescriptorProto_Label;
        FieldDescriptorProto_LabelSDKType: typeof _73.FieldDescriptorProto_Label;
        FieldDescriptorProto_LabelAmino: typeof _73.FieldDescriptorProto_Label;
        FileOptions_OptimizeMode: typeof _73.FileOptions_OptimizeMode;
        FileOptions_OptimizeModeSDKType: typeof _73.FileOptions_OptimizeMode;
        FileOptions_OptimizeModeAmino: typeof _73.FileOptions_OptimizeMode;
        FieldOptions_CType: typeof _73.FieldOptions_CType;
        FieldOptions_CTypeSDKType: typeof _73.FieldOptions_CType;
        FieldOptions_CTypeAmino: typeof _73.FieldOptions_CType;
        FieldOptions_JSType: typeof _73.FieldOptions_JSType;
        FieldOptions_JSTypeSDKType: typeof _73.FieldOptions_JSType;
        FieldOptions_JSTypeAmino: typeof _73.FieldOptions_JSType;
        MethodOptions_IdempotencyLevel: typeof _73.MethodOptions_IdempotencyLevel;
        MethodOptions_IdempotencyLevelSDKType: typeof _73.MethodOptions_IdempotencyLevel;
        MethodOptions_IdempotencyLevelAmino: typeof _73.MethodOptions_IdempotencyLevel;
        FileDescriptorSet: {
            typeUrl: string;
            encode(message: _73.FileDescriptorSet, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.FileDescriptorSet;
            fromPartial(object: Partial<_73.FileDescriptorSet>): _73.FileDescriptorSet;
            fromAmino(object: _73.FileDescriptorSetAmino): _73.FileDescriptorSet;
            toAmino(message: _73.FileDescriptorSet): _73.FileDescriptorSetAmino;
            fromAminoMsg(object: _73.FileDescriptorSetAminoMsg): _73.FileDescriptorSet;
            fromProtoMsg(message: _73.FileDescriptorSetProtoMsg): _73.FileDescriptorSet;
            toProto(message: _73.FileDescriptorSet): Uint8Array;
            toProtoMsg(message: _73.FileDescriptorSet): _73.FileDescriptorSetProtoMsg;
        };
        FileDescriptorProto: {
            typeUrl: string;
            encode(message: _73.FileDescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.FileDescriptorProto;
            fromPartial(object: Partial<_73.FileDescriptorProto>): _73.FileDescriptorProto;
            fromAmino(object: _73.FileDescriptorProtoAmino): _73.FileDescriptorProto;
            toAmino(message: _73.FileDescriptorProto): _73.FileDescriptorProtoAmino;
            fromAminoMsg(object: _73.FileDescriptorProtoAminoMsg): _73.FileDescriptorProto;
            fromProtoMsg(message: _73.FileDescriptorProtoProtoMsg): _73.FileDescriptorProto;
            toProto(message: _73.FileDescriptorProto): Uint8Array;
            toProtoMsg(message: _73.FileDescriptorProto): _73.FileDescriptorProtoProtoMsg;
        };
        DescriptorProto: {
            typeUrl: string;
            encode(message: _73.DescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.DescriptorProto;
            fromPartial(object: Partial<_73.DescriptorProto>): _73.DescriptorProto;
            fromAmino(object: _73.DescriptorProtoAmino): _73.DescriptorProto;
            toAmino(message: _73.DescriptorProto): _73.DescriptorProtoAmino;
            fromAminoMsg(object: _73.DescriptorProtoAminoMsg): _73.DescriptorProto;
            fromProtoMsg(message: _73.DescriptorProtoProtoMsg): _73.DescriptorProto;
            toProto(message: _73.DescriptorProto): Uint8Array;
            toProtoMsg(message: _73.DescriptorProto): _73.DescriptorProtoProtoMsg;
        };
        DescriptorProto_ExtensionRange: {
            typeUrl: string;
            encode(message: _73.DescriptorProto_ExtensionRange, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.DescriptorProto_ExtensionRange;
            fromPartial(object: Partial<_73.DescriptorProto_ExtensionRange>): _73.DescriptorProto_ExtensionRange;
            fromAmino(object: _73.DescriptorProto_ExtensionRangeAmino): _73.DescriptorProto_ExtensionRange;
            toAmino(message: _73.DescriptorProto_ExtensionRange): _73.DescriptorProto_ExtensionRangeAmino;
            fromAminoMsg(object: _73.DescriptorProto_ExtensionRangeAminoMsg): _73.DescriptorProto_ExtensionRange;
            fromProtoMsg(message: _73.DescriptorProto_ExtensionRangeProtoMsg): _73.DescriptorProto_ExtensionRange;
            toProto(message: _73.DescriptorProto_ExtensionRange): Uint8Array;
            toProtoMsg(message: _73.DescriptorProto_ExtensionRange): _73.DescriptorProto_ExtensionRangeProtoMsg;
        };
        DescriptorProto_ReservedRange: {
            typeUrl: string;
            encode(message: _73.DescriptorProto_ReservedRange, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.DescriptorProto_ReservedRange;
            fromPartial(object: Partial<_73.DescriptorProto_ReservedRange>): _73.DescriptorProto_ReservedRange;
            fromAmino(object: _73.DescriptorProto_ReservedRangeAmino): _73.DescriptorProto_ReservedRange;
            toAmino(message: _73.DescriptorProto_ReservedRange): _73.DescriptorProto_ReservedRangeAmino;
            fromAminoMsg(object: _73.DescriptorProto_ReservedRangeAminoMsg): _73.DescriptorProto_ReservedRange;
            fromProtoMsg(message: _73.DescriptorProto_ReservedRangeProtoMsg): _73.DescriptorProto_ReservedRange;
            toProto(message: _73.DescriptorProto_ReservedRange): Uint8Array;
            toProtoMsg(message: _73.DescriptorProto_ReservedRange): _73.DescriptorProto_ReservedRangeProtoMsg;
        };
        ExtensionRangeOptions: {
            typeUrl: string;
            encode(message: _73.ExtensionRangeOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.ExtensionRangeOptions;
            fromPartial(object: Partial<_73.ExtensionRangeOptions>): _73.ExtensionRangeOptions;
            fromAmino(object: _73.ExtensionRangeOptionsAmino): _73.ExtensionRangeOptions;
            toAmino(message: _73.ExtensionRangeOptions): _73.ExtensionRangeOptionsAmino;
            fromAminoMsg(object: _73.ExtensionRangeOptionsAminoMsg): _73.ExtensionRangeOptions;
            fromProtoMsg(message: _73.ExtensionRangeOptionsProtoMsg): _73.ExtensionRangeOptions;
            toProto(message: _73.ExtensionRangeOptions): Uint8Array;
            toProtoMsg(message: _73.ExtensionRangeOptions): _73.ExtensionRangeOptionsProtoMsg;
        };
        FieldDescriptorProto: {
            typeUrl: string;
            encode(message: _73.FieldDescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.FieldDescriptorProto;
            fromPartial(object: Partial<_73.FieldDescriptorProto>): _73.FieldDescriptorProto;
            fromAmino(object: _73.FieldDescriptorProtoAmino): _73.FieldDescriptorProto;
            toAmino(message: _73.FieldDescriptorProto): _73.FieldDescriptorProtoAmino;
            fromAminoMsg(object: _73.FieldDescriptorProtoAminoMsg): _73.FieldDescriptorProto;
            fromProtoMsg(message: _73.FieldDescriptorProtoProtoMsg): _73.FieldDescriptorProto;
            toProto(message: _73.FieldDescriptorProto): Uint8Array;
            toProtoMsg(message: _73.FieldDescriptorProto): _73.FieldDescriptorProtoProtoMsg;
        };
        OneofDescriptorProto: {
            typeUrl: string;
            encode(message: _73.OneofDescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.OneofDescriptorProto;
            fromPartial(object: Partial<_73.OneofDescriptorProto>): _73.OneofDescriptorProto;
            fromAmino(object: _73.OneofDescriptorProtoAmino): _73.OneofDescriptorProto;
            toAmino(message: _73.OneofDescriptorProto): _73.OneofDescriptorProtoAmino;
            fromAminoMsg(object: _73.OneofDescriptorProtoAminoMsg): _73.OneofDescriptorProto;
            fromProtoMsg(message: _73.OneofDescriptorProtoProtoMsg): _73.OneofDescriptorProto;
            toProto(message: _73.OneofDescriptorProto): Uint8Array;
            toProtoMsg(message: _73.OneofDescriptorProto): _73.OneofDescriptorProtoProtoMsg;
        };
        EnumDescriptorProto: {
            typeUrl: string;
            encode(message: _73.EnumDescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.EnumDescriptorProto;
            fromPartial(object: Partial<_73.EnumDescriptorProto>): _73.EnumDescriptorProto;
            fromAmino(object: _73.EnumDescriptorProtoAmino): _73.EnumDescriptorProto;
            toAmino(message: _73.EnumDescriptorProto): _73.EnumDescriptorProtoAmino;
            fromAminoMsg(object: _73.EnumDescriptorProtoAminoMsg): _73.EnumDescriptorProto;
            fromProtoMsg(message: _73.EnumDescriptorProtoProtoMsg): _73.EnumDescriptorProto;
            toProto(message: _73.EnumDescriptorProto): Uint8Array;
            toProtoMsg(message: _73.EnumDescriptorProto): _73.EnumDescriptorProtoProtoMsg;
        };
        EnumDescriptorProto_EnumReservedRange: {
            typeUrl: string;
            encode(message: _73.EnumDescriptorProto_EnumReservedRange, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.EnumDescriptorProto_EnumReservedRange;
            fromPartial(object: Partial<_73.EnumDescriptorProto_EnumReservedRange>): _73.EnumDescriptorProto_EnumReservedRange;
            fromAmino(object: _73.EnumDescriptorProto_EnumReservedRangeAmino): _73.EnumDescriptorProto_EnumReservedRange;
            toAmino(message: _73.EnumDescriptorProto_EnumReservedRange): _73.EnumDescriptorProto_EnumReservedRangeAmino;
            fromAminoMsg(object: _73.EnumDescriptorProto_EnumReservedRangeAminoMsg): _73.EnumDescriptorProto_EnumReservedRange;
            fromProtoMsg(message: _73.EnumDescriptorProto_EnumReservedRangeProtoMsg): _73.EnumDescriptorProto_EnumReservedRange;
            toProto(message: _73.EnumDescriptorProto_EnumReservedRange): Uint8Array;
            toProtoMsg(message: _73.EnumDescriptorProto_EnumReservedRange): _73.EnumDescriptorProto_EnumReservedRangeProtoMsg;
        };
        EnumValueDescriptorProto: {
            typeUrl: string;
            encode(message: _73.EnumValueDescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.EnumValueDescriptorProto;
            fromPartial(object: Partial<_73.EnumValueDescriptorProto>): _73.EnumValueDescriptorProto;
            fromAmino(object: _73.EnumValueDescriptorProtoAmino): _73.EnumValueDescriptorProto;
            toAmino(message: _73.EnumValueDescriptorProto): _73.EnumValueDescriptorProtoAmino;
            fromAminoMsg(object: _73.EnumValueDescriptorProtoAminoMsg): _73.EnumValueDescriptorProto;
            fromProtoMsg(message: _73.EnumValueDescriptorProtoProtoMsg): _73.EnumValueDescriptorProto;
            toProto(message: _73.EnumValueDescriptorProto): Uint8Array;
            toProtoMsg(message: _73.EnumValueDescriptorProto): _73.EnumValueDescriptorProtoProtoMsg;
        };
        ServiceDescriptorProto: {
            typeUrl: string;
            encode(message: _73.ServiceDescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.ServiceDescriptorProto;
            fromPartial(object: Partial<_73.ServiceDescriptorProto>): _73.ServiceDescriptorProto;
            fromAmino(object: _73.ServiceDescriptorProtoAmino): _73.ServiceDescriptorProto;
            toAmino(message: _73.ServiceDescriptorProto): _73.ServiceDescriptorProtoAmino;
            fromAminoMsg(object: _73.ServiceDescriptorProtoAminoMsg): _73.ServiceDescriptorProto;
            fromProtoMsg(message: _73.ServiceDescriptorProtoProtoMsg): _73.ServiceDescriptorProto;
            toProto(message: _73.ServiceDescriptorProto): Uint8Array;
            toProtoMsg(message: _73.ServiceDescriptorProto): _73.ServiceDescriptorProtoProtoMsg;
        };
        MethodDescriptorProto: {
            typeUrl: string;
            encode(message: _73.MethodDescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.MethodDescriptorProto;
            fromPartial(object: Partial<_73.MethodDescriptorProto>): _73.MethodDescriptorProto;
            fromAmino(object: _73.MethodDescriptorProtoAmino): _73.MethodDescriptorProto;
            toAmino(message: _73.MethodDescriptorProto): _73.MethodDescriptorProtoAmino;
            fromAminoMsg(object: _73.MethodDescriptorProtoAminoMsg): _73.MethodDescriptorProto;
            fromProtoMsg(message: _73.MethodDescriptorProtoProtoMsg): _73.MethodDescriptorProto;
            toProto(message: _73.MethodDescriptorProto): Uint8Array;
            toProtoMsg(message: _73.MethodDescriptorProto): _73.MethodDescriptorProtoProtoMsg;
        };
        FileOptions: {
            typeUrl: string;
            encode(message: _73.FileOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.FileOptions;
            fromPartial(object: Partial<_73.FileOptions>): _73.FileOptions;
            fromAmino(object: _73.FileOptionsAmino): _73.FileOptions;
            toAmino(message: _73.FileOptions): _73.FileOptionsAmino;
            fromAminoMsg(object: _73.FileOptionsAminoMsg): _73.FileOptions;
            fromProtoMsg(message: _73.FileOptionsProtoMsg): _73.FileOptions;
            toProto(message: _73.FileOptions): Uint8Array;
            toProtoMsg(message: _73.FileOptions): _73.FileOptionsProtoMsg;
        };
        MessageOptions: {
            typeUrl: string;
            encode(message: _73.MessageOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.MessageOptions;
            fromPartial(object: Partial<_73.MessageOptions>): _73.MessageOptions;
            fromAmino(object: _73.MessageOptionsAmino): _73.MessageOptions;
            toAmino(message: _73.MessageOptions): _73.MessageOptionsAmino;
            fromAminoMsg(object: _73.MessageOptionsAminoMsg): _73.MessageOptions;
            fromProtoMsg(message: _73.MessageOptionsProtoMsg): _73.MessageOptions;
            toProto(message: _73.MessageOptions): Uint8Array;
            toProtoMsg(message: _73.MessageOptions): _73.MessageOptionsProtoMsg;
        };
        FieldOptions: {
            typeUrl: string;
            encode(message: _73.FieldOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.FieldOptions;
            fromPartial(object: Partial<_73.FieldOptions>): _73.FieldOptions;
            fromAmino(object: _73.FieldOptionsAmino): _73.FieldOptions;
            toAmino(message: _73.FieldOptions): _73.FieldOptionsAmino;
            fromAminoMsg(object: _73.FieldOptionsAminoMsg): _73.FieldOptions;
            fromProtoMsg(message: _73.FieldOptionsProtoMsg): _73.FieldOptions;
            toProto(message: _73.FieldOptions): Uint8Array;
            toProtoMsg(message: _73.FieldOptions): _73.FieldOptionsProtoMsg;
        };
        OneofOptions: {
            typeUrl: string;
            encode(message: _73.OneofOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.OneofOptions;
            fromPartial(object: Partial<_73.OneofOptions>): _73.OneofOptions;
            fromAmino(object: _73.OneofOptionsAmino): _73.OneofOptions;
            toAmino(message: _73.OneofOptions): _73.OneofOptionsAmino;
            fromAminoMsg(object: _73.OneofOptionsAminoMsg): _73.OneofOptions;
            fromProtoMsg(message: _73.OneofOptionsProtoMsg): _73.OneofOptions;
            toProto(message: _73.OneofOptions): Uint8Array;
            toProtoMsg(message: _73.OneofOptions): _73.OneofOptionsProtoMsg;
        };
        EnumOptions: {
            typeUrl: string;
            encode(message: _73.EnumOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.EnumOptions;
            fromPartial(object: Partial<_73.EnumOptions>): _73.EnumOptions;
            fromAmino(object: _73.EnumOptionsAmino): _73.EnumOptions;
            toAmino(message: _73.EnumOptions): _73.EnumOptionsAmino;
            fromAminoMsg(object: _73.EnumOptionsAminoMsg): _73.EnumOptions;
            fromProtoMsg(message: _73.EnumOptionsProtoMsg): _73.EnumOptions;
            toProto(message: _73.EnumOptions): Uint8Array;
            toProtoMsg(message: _73.EnumOptions): _73.EnumOptionsProtoMsg;
        };
        EnumValueOptions: {
            typeUrl: string;
            encode(message: _73.EnumValueOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.EnumValueOptions;
            fromPartial(object: Partial<_73.EnumValueOptions>): _73.EnumValueOptions;
            fromAmino(object: _73.EnumValueOptionsAmino): _73.EnumValueOptions;
            toAmino(message: _73.EnumValueOptions): _73.EnumValueOptionsAmino;
            fromAminoMsg(object: _73.EnumValueOptionsAminoMsg): _73.EnumValueOptions;
            fromProtoMsg(message: _73.EnumValueOptionsProtoMsg): _73.EnumValueOptions;
            toProto(message: _73.EnumValueOptions): Uint8Array;
            toProtoMsg(message: _73.EnumValueOptions): _73.EnumValueOptionsProtoMsg;
        };
        ServiceOptions: {
            typeUrl: string;
            encode(message: _73.ServiceOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.ServiceOptions;
            fromPartial(object: Partial<_73.ServiceOptions>): _73.ServiceOptions;
            fromAmino(object: _73.ServiceOptionsAmino): _73.ServiceOptions;
            toAmino(message: _73.ServiceOptions): _73.ServiceOptionsAmino;
            fromAminoMsg(object: _73.ServiceOptionsAminoMsg): _73.ServiceOptions;
            fromProtoMsg(message: _73.ServiceOptionsProtoMsg): _73.ServiceOptions;
            toProto(message: _73.ServiceOptions): Uint8Array;
            toProtoMsg(message: _73.ServiceOptions): _73.ServiceOptionsProtoMsg;
        };
        MethodOptions: {
            typeUrl: string;
            encode(message: _73.MethodOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.MethodOptions;
            fromPartial(object: Partial<_73.MethodOptions>): _73.MethodOptions;
            fromAmino(object: _73.MethodOptionsAmino): _73.MethodOptions;
            toAmino(message: _73.MethodOptions): _73.MethodOptionsAmino;
            fromAminoMsg(object: _73.MethodOptionsAminoMsg): _73.MethodOptions;
            fromProtoMsg(message: _73.MethodOptionsProtoMsg): _73.MethodOptions;
            toProto(message: _73.MethodOptions): Uint8Array;
            toProtoMsg(message: _73.MethodOptions): _73.MethodOptionsProtoMsg;
        };
        UninterpretedOption: {
            typeUrl: string;
            encode(message: _73.UninterpretedOption, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.UninterpretedOption;
            fromPartial(object: Partial<_73.UninterpretedOption>): _73.UninterpretedOption;
            fromAmino(object: _73.UninterpretedOptionAmino): _73.UninterpretedOption;
            toAmino(message: _73.UninterpretedOption): _73.UninterpretedOptionAmino;
            fromAminoMsg(object: _73.UninterpretedOptionAminoMsg): _73.UninterpretedOption;
            fromProtoMsg(message: _73.UninterpretedOptionProtoMsg): _73.UninterpretedOption;
            toProto(message: _73.UninterpretedOption): Uint8Array;
            toProtoMsg(message: _73.UninterpretedOption): _73.UninterpretedOptionProtoMsg;
        };
        UninterpretedOption_NamePart: {
            typeUrl: string;
            encode(message: _73.UninterpretedOption_NamePart, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.UninterpretedOption_NamePart;
            fromPartial(object: Partial<_73.UninterpretedOption_NamePart>): _73.UninterpretedOption_NamePart;
            fromAmino(object: _73.UninterpretedOption_NamePartAmino): _73.UninterpretedOption_NamePart;
            toAmino(message: _73.UninterpretedOption_NamePart): _73.UninterpretedOption_NamePartAmino;
            fromAminoMsg(object: _73.UninterpretedOption_NamePartAminoMsg): _73.UninterpretedOption_NamePart;
            fromProtoMsg(message: _73.UninterpretedOption_NamePartProtoMsg): _73.UninterpretedOption_NamePart;
            toProto(message: _73.UninterpretedOption_NamePart): Uint8Array;
            toProtoMsg(message: _73.UninterpretedOption_NamePart): _73.UninterpretedOption_NamePartProtoMsg;
        };
        SourceCodeInfo: {
            typeUrl: string;
            encode(message: _73.SourceCodeInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.SourceCodeInfo;
            fromPartial(object: Partial<_73.SourceCodeInfo>): _73.SourceCodeInfo;
            fromAmino(object: _73.SourceCodeInfoAmino): _73.SourceCodeInfo;
            toAmino(message: _73.SourceCodeInfo): _73.SourceCodeInfoAmino;
            fromAminoMsg(object: _73.SourceCodeInfoAminoMsg): _73.SourceCodeInfo;
            fromProtoMsg(message: _73.SourceCodeInfoProtoMsg): _73.SourceCodeInfo;
            toProto(message: _73.SourceCodeInfo): Uint8Array;
            toProtoMsg(message: _73.SourceCodeInfo): _73.SourceCodeInfoProtoMsg;
        };
        SourceCodeInfo_Location: {
            typeUrl: string;
            encode(message: _73.SourceCodeInfo_Location, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.SourceCodeInfo_Location;
            fromPartial(object: Partial<_73.SourceCodeInfo_Location>): _73.SourceCodeInfo_Location;
            fromAmino(object: _73.SourceCodeInfo_LocationAmino): _73.SourceCodeInfo_Location;
            toAmino(message: _73.SourceCodeInfo_Location): _73.SourceCodeInfo_LocationAmino;
            fromAminoMsg(object: _73.SourceCodeInfo_LocationAminoMsg): _73.SourceCodeInfo_Location;
            fromProtoMsg(message: _73.SourceCodeInfo_LocationProtoMsg): _73.SourceCodeInfo_Location;
            toProto(message: _73.SourceCodeInfo_Location): Uint8Array;
            toProtoMsg(message: _73.SourceCodeInfo_Location): _73.SourceCodeInfo_LocationProtoMsg;
        };
        GeneratedCodeInfo: {
            typeUrl: string;
            encode(message: _73.GeneratedCodeInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.GeneratedCodeInfo;
            fromPartial(object: Partial<_73.GeneratedCodeInfo>): _73.GeneratedCodeInfo;
            fromAmino(object: _73.GeneratedCodeInfoAmino): _73.GeneratedCodeInfo;
            toAmino(message: _73.GeneratedCodeInfo): _73.GeneratedCodeInfoAmino;
            fromAminoMsg(object: _73.GeneratedCodeInfoAminoMsg): _73.GeneratedCodeInfo;
            fromProtoMsg(message: _73.GeneratedCodeInfoProtoMsg): _73.GeneratedCodeInfo;
            toProto(message: _73.GeneratedCodeInfo): Uint8Array;
            toProtoMsg(message: _73.GeneratedCodeInfo): _73.GeneratedCodeInfoProtoMsg;
        };
        GeneratedCodeInfo_Annotation: {
            typeUrl: string;
            encode(message: _73.GeneratedCodeInfo_Annotation, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _73.GeneratedCodeInfo_Annotation;
            fromPartial(object: Partial<_73.GeneratedCodeInfo_Annotation>): _73.GeneratedCodeInfo_Annotation;
            fromAmino(object: _73.GeneratedCodeInfo_AnnotationAmino): _73.GeneratedCodeInfo_Annotation;
            toAmino(message: _73.GeneratedCodeInfo_Annotation): _73.GeneratedCodeInfo_AnnotationAmino;
            fromAminoMsg(object: _73.GeneratedCodeInfo_AnnotationAminoMsg): _73.GeneratedCodeInfo_Annotation;
            fromProtoMsg(message: _73.GeneratedCodeInfo_AnnotationProtoMsg): _73.GeneratedCodeInfo_Annotation;
            toProto(message: _73.GeneratedCodeInfo_Annotation): Uint8Array;
            toProtoMsg(message: _73.GeneratedCodeInfo_Annotation): _73.GeneratedCodeInfo_AnnotationProtoMsg;
        };
        Any: {
            typeUrl: string;
            encode(message: _72.Any, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
            decode(input: Uint8Array | import("..").BinaryReader, length?: number): _72.Any;
            fromPartial(object: Partial<_72.Any>): _72.Any;
            fromAmino(object: _72.AnyAmino): _72.Any;
            toAmino(message: _72.Any): _72.AnyAmino;
            fromAminoMsg(object: _72.AnyAminoMsg): _72.Any;
            fromProtoMsg(message: _72.AnyProtoMsg): _72.Any;
            toProto(message: _72.Any): Uint8Array;
            toProtoMsg(message: _72.Any): _72.AnyProtoMsg;
        };
    };
}