@0xkaleab/sdk-js 0.2.7

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

@@ -0,0 +1,2322 @@
+import * as _42 from "./type/timeofday";
+import * as _43 from "./type/quaternion";
+import * as _44 from "./type/postal_address";
+import * as _45 from "./type/phone_number";
+import * as _46 from "./type/month";
+import * as _47 from "./type/money";
+import * as _48 from "./type/localized_text";
+import * as _49 from "./type/latlng";
+import * as _50 from "./type/interval";
+import * as _51 from "./type/fraction";
+import * as _52 from "./type/expr";
+import * as _53 from "./type/decimal";
+import * as _54 from "./type/dayofweek";
+import * as _55 from "./type/datetime";
+import * as _56 from "./type/date";
+import * as _57 from "./type/color";
+import * as _58 from "./type/calendar_period";
+import * as _59 from "./rpc/status";
+import * as _60 from "./rpc/error_details";
+import * as _61 from "./rpc/code";
+import * as _62 from "./protobuf/timestamp";
+import * as _63 from "./protobuf/duration";
+import * as _64 from "./protobuf/descriptor";
+import * as _65 from "./protobuf/wrappers";
+import * as _66 from "./protobuf/any";
+import * as _67 from "./protobuf/struct";
+import * as _68 from "./protobuf/empty";
+import * as _69 from "./protobuf/field_mask";
+import * as _70 from "./longrunning/operations";
+import * as _71 from "./iam/v1/policy";
+import * as _72 from "./iam/v1/options";
+import * as _73 from "./iam/v1/iam_policy";
+import * as _74 from "./geo/type/viewport";
+import * as _75 from "./bytestream/bytestream";
+import * as _76 from "./api/visibility";
+import * as _77 from "./api/routing";
+import * as _78 from "./api/resource";
+import * as _79 from "./api/launch_stage";
+import * as _80 from "./api/httpbody";
+import * as _81 from "./api/http";
+import * as _82 from "./api/field_info";
+import * as _83 from "./api/field_behavior";
+import * as _84 from "./api/client";
+export declare namespace google {
+    const type: {
+        calendarPeriodFromJSON(object: any): _58.CalendarPeriod;
+        calendarPeriodToJSON(object: _58.CalendarPeriod): string;
+        CalendarPeriod: typeof _58.CalendarPeriod;
+        CalendarPeriodAmino: typeof _58.CalendarPeriod;
+        Color: {
+            typeUrl: string;
+            is(o: any): o is _57.Color;
+            isAmino(o: any): o is _57.ColorAmino;
+            encode(message: _57.Color, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _57.Color;
+            fromPartial(object: import("../helpers").DeepPartial<_57.Color>): _57.Color;
+            fromAmino(object: _57.ColorAmino): _57.Color;
+            toAmino(message: _57.Color): _57.ColorAmino;
+            fromAminoMsg(object: _57.ColorAminoMsg): _57.Color;
+            fromProtoMsg(message: _57.ColorProtoMsg): _57.Color;
+            toProto(message: _57.Color): Uint8Array;
+            toProtoMsg(message: _57.Color): _57.ColorProtoMsg;
+            registerTypeUrl(): void;
+        };
+        Date: {
+            typeUrl: string;
+            is(o: any): o is _56.Date;
+            isAmino(o: any): o is _56.DateAmino;
+            encode(message: _56.Date, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _56.Date;
+            fromPartial(object: import("../helpers").DeepPartial<_56.Date>): _56.Date;
+            fromAmino(object: _56.DateAmino): _56.Date;
+            toAmino(message: _56.Date): _56.DateAmino;
+            fromAminoMsg(object: _56.DateAminoMsg): _56.Date;
+            fromProtoMsg(message: _56.DateProtoMsg): _56.Date;
+            toProto(message: _56.Date): Uint8Array;
+            toProtoMsg(message: _56.Date): _56.DateProtoMsg;
+            registerTypeUrl(): void;
+        };
+        DateTime: {
+            typeUrl: string;
+            is(o: any): o is _55.DateTime;
+            isAmino(o: any): o is _55.DateTimeAmino;
+            encode(message: _55.DateTime, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _55.DateTime;
+            fromPartial(object: import("../helpers").DeepPartial<_55.DateTime>): _55.DateTime;
+            fromAmino(object: _55.DateTimeAmino): _55.DateTime;
+            toAmino(message: _55.DateTime): _55.DateTimeAmino;
+            fromAminoMsg(object: _55.DateTimeAminoMsg): _55.DateTime;
+            fromProtoMsg(message: _55.DateTimeProtoMsg): _55.DateTime;
+            toProto(message: _55.DateTime): Uint8Array;
+            toProtoMsg(message: _55.DateTime): _55.DateTimeProtoMsg;
+            registerTypeUrl(): void;
+        };
+        TimeZone: {
+            typeUrl: string;
+            is(o: any): o is _55.TimeZone;
+            isAmino(o: any): o is _55.TimeZoneAmino;
+            encode(message: _55.TimeZone, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _55.TimeZone;
+            fromPartial(object: import("../helpers").DeepPartial<_55.TimeZone>): _55.TimeZone;
+            fromAmino(object: _55.TimeZoneAmino): _55.TimeZone;
+            toAmino(message: _55.TimeZone): _55.TimeZoneAmino;
+            fromAminoMsg(object: _55.TimeZoneAminoMsg): _55.TimeZone;
+            fromProtoMsg(message: _55.TimeZoneProtoMsg): _55.TimeZone;
+            toProto(message: _55.TimeZone): Uint8Array;
+            toProtoMsg(message: _55.TimeZone): _55.TimeZoneProtoMsg;
+            registerTypeUrl(): void;
+        };
+        dayOfWeekFromJSON(object: any): _54.DayOfWeek;
+        dayOfWeekToJSON(object: _54.DayOfWeek): string;
+        DayOfWeek: typeof _54.DayOfWeek;
+        DayOfWeekAmino: typeof _54.DayOfWeek;
+        Decimal: {
+            typeUrl: string;
+            is(o: any): o is _53.Decimal;
+            isAmino(o: any): o is _53.DecimalAmino;
+            encode(message: _53.Decimal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _53.Decimal;
+            fromPartial(object: import("../helpers").DeepPartial<_53.Decimal>): _53.Decimal;
+            fromAmino(object: _53.DecimalAmino): _53.Decimal;
+            toAmino(message: _53.Decimal): _53.DecimalAmino;
+            fromAminoMsg(object: _53.DecimalAminoMsg): _53.Decimal;
+            fromProtoMsg(message: _53.DecimalProtoMsg): _53.Decimal;
+            toProto(message: _53.Decimal): Uint8Array;
+            toProtoMsg(message: _53.Decimal): _53.DecimalProtoMsg;
+            registerTypeUrl(): void;
+        };
+        Expr: {
+            typeUrl: string;
+            is(o: any): o is _52.Expr;
+            isAmino(o: any): o is _52.ExprAmino;
+            encode(message: _52.Expr, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _52.Expr;
+            fromPartial(object: import("../helpers").DeepPartial<_52.Expr>): _52.Expr;
+            fromAmino(object: _52.ExprAmino): _52.Expr;
+            toAmino(message: _52.Expr): _52.ExprAmino;
+            fromAminoMsg(object: _52.ExprAminoMsg): _52.Expr;
+            fromProtoMsg(message: _52.ExprProtoMsg): _52.Expr;
+            toProto(message: _52.Expr): Uint8Array;
+            toProtoMsg(message: _52.Expr): _52.ExprProtoMsg;
+            registerTypeUrl(): void;
+        };
+        Fraction: {
+            typeUrl: string;
+            is(o: any): o is _51.Fraction;
+            isAmino(o: any): o is _51.FractionAmino;
+            encode(message: _51.Fraction, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _51.Fraction;
+            fromPartial(object: import("../helpers").DeepPartial<_51.Fraction>): _51.Fraction;
+            fromAmino(object: _51.FractionAmino): _51.Fraction;
+            toAmino(message: _51.Fraction): _51.FractionAmino;
+            fromAminoMsg(object: _51.FractionAminoMsg): _51.Fraction;
+            fromProtoMsg(message: _51.FractionProtoMsg): _51.Fraction;
+            toProto(message: _51.Fraction): Uint8Array;
+            toProtoMsg(message: _51.Fraction): _51.FractionProtoMsg;
+            registerTypeUrl(): void;
+        };
+        Interval: {
+            typeUrl: string;
+            is(o: any): o is _50.Interval;
+            isAmino(o: any): o is _50.IntervalAmino;
+            encode(message: _50.Interval, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _50.Interval;
+            fromPartial(object: import("../helpers").DeepPartial<_50.Interval>): _50.Interval;
+            fromAmino(object: _50.IntervalAmino): _50.Interval;
+            toAmino(message: _50.Interval): _50.IntervalAmino;
+            fromAminoMsg(object: _50.IntervalAminoMsg): _50.Interval;
+            fromProtoMsg(message: _50.IntervalProtoMsg): _50.Interval;
+            toProto(message: _50.Interval): Uint8Array;
+            toProtoMsg(message: _50.Interval): _50.IntervalProtoMsg;
+            registerTypeUrl(): void;
+        };
+        LatLng: {
+            typeUrl: string;
+            is(o: any): o is _49.LatLng;
+            isAmino(o: any): o is _49.LatLngAmino;
+            encode(message: _49.LatLng, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _49.LatLng;
+            fromPartial(object: import("../helpers").DeepPartial<_49.LatLng>): _49.LatLng;
+            fromAmino(object: _49.LatLngAmino): _49.LatLng;
+            toAmino(message: _49.LatLng): _49.LatLngAmino;
+            fromAminoMsg(object: _49.LatLngAminoMsg): _49.LatLng;
+            fromProtoMsg(message: _49.LatLngProtoMsg): _49.LatLng;
+            toProto(message: _49.LatLng): Uint8Array;
+            toProtoMsg(message: _49.LatLng): _49.LatLngProtoMsg;
+            registerTypeUrl(): void;
+        };
+        LocalizedText: {
+            typeUrl: string;
+            is(o: any): o is _48.LocalizedText;
+            isAmino(o: any): o is _48.LocalizedTextAmino;
+            encode(message: _48.LocalizedText, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _48.LocalizedText;
+            fromPartial(object: import("../helpers").DeepPartial<_48.LocalizedText>): _48.LocalizedText;
+            fromAmino(object: _48.LocalizedTextAmino): _48.LocalizedText;
+            toAmino(message: _48.LocalizedText): _48.LocalizedTextAmino;
+            fromAminoMsg(object: _48.LocalizedTextAminoMsg): _48.LocalizedText;
+            fromProtoMsg(message: _48.LocalizedTextProtoMsg): _48.LocalizedText;
+            toProto(message: _48.LocalizedText): Uint8Array;
+            toProtoMsg(message: _48.LocalizedText): _48.LocalizedTextProtoMsg;
+            registerTypeUrl(): void;
+        };
+        Money: {
+            typeUrl: string;
+            is(o: any): o is _47.Money;
+            isAmino(o: any): o is _47.MoneyAmino;
+            encode(message: _47.Money, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _47.Money;
+            fromPartial(object: import("../helpers").DeepPartial<_47.Money>): _47.Money;
+            fromAmino(object: _47.MoneyAmino): _47.Money;
+            toAmino(message: _47.Money): _47.MoneyAmino;
+            fromAminoMsg(object: _47.MoneyAminoMsg): _47.Money;
+            fromProtoMsg(message: _47.MoneyProtoMsg): _47.Money;
+            toProto(message: _47.Money): Uint8Array;
+            toProtoMsg(message: _47.Money): _47.MoneyProtoMsg;
+            registerTypeUrl(): void;
+        };
+        monthFromJSON(object: any): _46.Month;
+        monthToJSON(object: _46.Month): string;
+        Month: typeof _46.Month;
+        MonthAmino: typeof _46.Month;
+        PhoneNumber: {
+            typeUrl: string;
+            is(o: any): o is _45.PhoneNumber;
+            isAmino(o: any): o is _45.PhoneNumberAmino;
+            encode(message: _45.PhoneNumber, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _45.PhoneNumber;
+            fromPartial(object: import("../helpers").DeepPartial<_45.PhoneNumber>): _45.PhoneNumber;
+            fromAmino(object: _45.PhoneNumberAmino): _45.PhoneNumber;
+            toAmino(message: _45.PhoneNumber): _45.PhoneNumberAmino;
+            fromAminoMsg(object: _45.PhoneNumberAminoMsg): _45.PhoneNumber;
+            fromProtoMsg(message: _45.PhoneNumberProtoMsg): _45.PhoneNumber;
+            toProto(message: _45.PhoneNumber): Uint8Array;
+            toProtoMsg(message: _45.PhoneNumber): _45.PhoneNumberProtoMsg;
+            registerTypeUrl(): void;
+        };
+        PhoneNumber_ShortCode: {
+            typeUrl: string;
+            is(o: any): o is _45.PhoneNumber_ShortCode;
+            isAmino(o: any): o is _45.PhoneNumber_ShortCodeAmino;
+            encode(message: _45.PhoneNumber_ShortCode, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _45.PhoneNumber_ShortCode;
+            fromPartial(object: import("../helpers").DeepPartial<_45.PhoneNumber_ShortCode>): _45.PhoneNumber_ShortCode;
+            fromAmino(object: _45.PhoneNumber_ShortCodeAmino): _45.PhoneNumber_ShortCode;
+            toAmino(message: _45.PhoneNumber_ShortCode): _45.PhoneNumber_ShortCodeAmino;
+            fromAminoMsg(object: _45.PhoneNumber_ShortCodeAminoMsg): _45.PhoneNumber_ShortCode;
+            fromProtoMsg(message: _45.PhoneNumber_ShortCodeProtoMsg): _45.PhoneNumber_ShortCode;
+            toProto(message: _45.PhoneNumber_ShortCode): Uint8Array;
+            toProtoMsg(message: _45.PhoneNumber_ShortCode): _45.PhoneNumber_ShortCodeProtoMsg;
+            registerTypeUrl(): void;
+        };
+        PostalAddress: {
+            typeUrl: string;
+            is(o: any): o is _44.PostalAddress;
+            isAmino(o: any): o is _44.PostalAddressAmino;
+            encode(message: _44.PostalAddress, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _44.PostalAddress;
+            fromPartial(object: import("../helpers").DeepPartial<_44.PostalAddress>): _44.PostalAddress;
+            fromAmino(object: _44.PostalAddressAmino): _44.PostalAddress;
+            toAmino(message: _44.PostalAddress): _44.PostalAddressAmino;
+            fromAminoMsg(object: _44.PostalAddressAminoMsg): _44.PostalAddress;
+            fromProtoMsg(message: _44.PostalAddressProtoMsg): _44.PostalAddress;
+            toProto(message: _44.PostalAddress): Uint8Array;
+            toProtoMsg(message: _44.PostalAddress): _44.PostalAddressProtoMsg;
+            registerTypeUrl(): void;
+        };
+        Quaternion: {
+            typeUrl: string;
+            is(o: any): o is _43.Quaternion;
+            isAmino(o: any): o is _43.QuaternionAmino;
+            encode(message: _43.Quaternion, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _43.Quaternion;
+            fromPartial(object: import("../helpers").DeepPartial<_43.Quaternion>): _43.Quaternion;
+            fromAmino(object: _43.QuaternionAmino): _43.Quaternion;
+            toAmino(message: _43.Quaternion): _43.QuaternionAmino;
+            fromAminoMsg(object: _43.QuaternionAminoMsg): _43.Quaternion;
+            fromProtoMsg(message: _43.QuaternionProtoMsg): _43.Quaternion;
+            toProto(message: _43.Quaternion): Uint8Array;
+            toProtoMsg(message: _43.Quaternion): _43.QuaternionProtoMsg;
+            registerTypeUrl(): void;
+        };
+        TimeOfDay: {
+            typeUrl: string;
+            is(o: any): o is _42.TimeOfDay;
+            isAmino(o: any): o is _42.TimeOfDayAmino;
+            encode(message: _42.TimeOfDay, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _42.TimeOfDay;
+            fromPartial(object: import("../helpers").DeepPartial<_42.TimeOfDay>): _42.TimeOfDay;
+            fromAmino(object: _42.TimeOfDayAmino): _42.TimeOfDay;
+            toAmino(message: _42.TimeOfDay): _42.TimeOfDayAmino;
+            fromAminoMsg(object: _42.TimeOfDayAminoMsg): _42.TimeOfDay;
+            fromProtoMsg(message: _42.TimeOfDayProtoMsg): _42.TimeOfDay;
+            toProto(message: _42.TimeOfDay): Uint8Array;
+            toProtoMsg(message: _42.TimeOfDay): _42.TimeOfDayProtoMsg;
+            registerTypeUrl(): void;
+        };
+    };
+    const rpc: {
+        codeFromJSON(object: any): _61.Code;
+        codeToJSON(object: _61.Code): string;
+        Code: typeof _61.Code;
+        CodeAmino: typeof _61.Code;
+        ErrorInfo_MetadataEntry: {
+            encode(message: _60.ErrorInfo_MetadataEntry, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _60.ErrorInfo_MetadataEntry;
+            fromPartial(object: import("../helpers").DeepPartial<_60.ErrorInfo_MetadataEntry>): _60.ErrorInfo_MetadataEntry;
+            fromAmino(object: _60.ErrorInfo_MetadataEntryAmino): _60.ErrorInfo_MetadataEntry;
+            toAmino(message: _60.ErrorInfo_MetadataEntry): _60.ErrorInfo_MetadataEntryAmino;
+            fromAminoMsg(object: _60.ErrorInfo_MetadataEntryAminoMsg): _60.ErrorInfo_MetadataEntry;
+            fromProtoMsg(message: _60.ErrorInfo_MetadataEntryProtoMsg): _60.ErrorInfo_MetadataEntry;
+            toProto(message: _60.ErrorInfo_MetadataEntry): Uint8Array;
+            registerTypeUrl(): void;
+        };
+        ErrorInfo: {
+            typeUrl: string;
+            is(o: any): o is _60.ErrorInfo;
+            isAmino(o: any): o is _60.ErrorInfoAmino;
+            encode(message: _60.ErrorInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _60.ErrorInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_60.ErrorInfo>): _60.ErrorInfo;
+            fromAmino(object: _60.ErrorInfoAmino): _60.ErrorInfo;
+            toAmino(message: _60.ErrorInfo): _60.ErrorInfoAmino;
+            fromAminoMsg(object: _60.ErrorInfoAminoMsg): _60.ErrorInfo;
+            fromProtoMsg(message: _60.ErrorInfoProtoMsg): _60.ErrorInfo;
+            toProto(message: _60.ErrorInfo): Uint8Array;
+            toProtoMsg(message: _60.ErrorInfo): _60.ErrorInfoProtoMsg;
+            registerTypeUrl(): void;
+        };
+        RetryInfo: {
+            typeUrl: string;
+            is(o: any): o is _60.RetryInfo;
+            isAmino(o: any): o is _60.RetryInfoAmino;
+            encode(message: _60.RetryInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _60.RetryInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_60.RetryInfo>): _60.RetryInfo;
+            fromAmino(object: _60.RetryInfoAmino): _60.RetryInfo;
+            toAmino(message: _60.RetryInfo): _60.RetryInfoAmino;
+            fromAminoMsg(object: _60.RetryInfoAminoMsg): _60.RetryInfo;
+            fromProtoMsg(message: _60.RetryInfoProtoMsg): _60.RetryInfo;
+            toProto(message: _60.RetryInfo): Uint8Array;
+            toProtoMsg(message: _60.RetryInfo): _60.RetryInfoProtoMsg;
+            registerTypeUrl(): void;
+        };
+        DebugInfo: {
+            typeUrl: string;
+            is(o: any): o is _60.DebugInfo;
+            isAmino(o: any): o is _60.DebugInfoAmino;
+            encode(message: _60.DebugInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _60.DebugInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_60.DebugInfo>): _60.DebugInfo;
+            fromAmino(object: _60.DebugInfoAmino): _60.DebugInfo;
+            toAmino(message: _60.DebugInfo): _60.DebugInfoAmino;
+            fromAminoMsg(object: _60.DebugInfoAminoMsg): _60.DebugInfo;
+            fromProtoMsg(message: _60.DebugInfoProtoMsg): _60.DebugInfo;
+            toProto(message: _60.DebugInfo): Uint8Array;
+            toProtoMsg(message: _60.DebugInfo): _60.DebugInfoProtoMsg;
+            registerTypeUrl(): void;
+        };
+        QuotaFailure: {
+            typeUrl: string;
+            is(o: any): o is _60.QuotaFailure;
+            isAmino(o: any): o is _60.QuotaFailureAmino;
+            encode(message: _60.QuotaFailure, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _60.QuotaFailure;
+            fromPartial(object: import("../helpers").DeepPartial<_60.QuotaFailure>): _60.QuotaFailure;
+            fromAmino(object: _60.QuotaFailureAmino): _60.QuotaFailure;
+            toAmino(message: _60.QuotaFailure): _60.QuotaFailureAmino;
+            fromAminoMsg(object: _60.QuotaFailureAminoMsg): _60.QuotaFailure;
+            fromProtoMsg(message: _60.QuotaFailureProtoMsg): _60.QuotaFailure;
+            toProto(message: _60.QuotaFailure): Uint8Array;
+            toProtoMsg(message: _60.QuotaFailure): _60.QuotaFailureProtoMsg;
+            registerTypeUrl(): void;
+        };
+        QuotaFailure_Violation_QuotaDimensionsEntry: {
+            encode(message: _60.QuotaFailure_Violation_QuotaDimensionsEntry, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _60.QuotaFailure_Violation_QuotaDimensionsEntry;
+            fromPartial(object: import("../helpers").DeepPartial<_60.QuotaFailure_Violation_QuotaDimensionsEntry>): _60.QuotaFailure_Violation_QuotaDimensionsEntry;
+            fromAmino(object: _60.QuotaFailure_Violation_QuotaDimensionsEntryAmino): _60.QuotaFailure_Violation_QuotaDimensionsEntry;
+            toAmino(message: _60.QuotaFailure_Violation_QuotaDimensionsEntry): _60.QuotaFailure_Violation_QuotaDimensionsEntryAmino;
+            fromAminoMsg(object: _60.QuotaFailure_Violation_QuotaDimensionsEntryAminoMsg): _60.QuotaFailure_Violation_QuotaDimensionsEntry;
+            fromProtoMsg(message: _60.QuotaFailure_Violation_QuotaDimensionsEntryProtoMsg): _60.QuotaFailure_Violation_QuotaDimensionsEntry;
+            toProto(message: _60.QuotaFailure_Violation_QuotaDimensionsEntry): Uint8Array;
+            registerTypeUrl(): void;
+        };
+        QuotaFailure_Violation: {
+            typeUrl: string;
+            is(o: any): o is _60.QuotaFailure_Violation;
+            isAmino(o: any): o is _60.QuotaFailure_ViolationAmino;
+            encode(message: _60.QuotaFailure_Violation, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _60.QuotaFailure_Violation;
+            fromPartial(object: import("../helpers").DeepPartial<_60.QuotaFailure_Violation>): _60.QuotaFailure_Violation;
+            fromAmino(object: _60.QuotaFailure_ViolationAmino): _60.QuotaFailure_Violation;
+            toAmino(message: _60.QuotaFailure_Violation): _60.QuotaFailure_ViolationAmino;
+            fromAminoMsg(object: _60.QuotaFailure_ViolationAminoMsg): _60.QuotaFailure_Violation;
+            fromProtoMsg(message: _60.QuotaFailure_ViolationProtoMsg): _60.QuotaFailure_Violation;
+            toProto(message: _60.QuotaFailure_Violation): Uint8Array;
+            toProtoMsg(message: _60.QuotaFailure_Violation): _60.QuotaFailure_ViolationProtoMsg;
+            registerTypeUrl(): void;
+        };
+        PreconditionFailure: {
+            typeUrl: string;
+            is(o: any): o is _60.PreconditionFailure;
+            isAmino(o: any): o is _60.PreconditionFailureAmino;
+            encode(message: _60.PreconditionFailure, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _60.PreconditionFailure;
+            fromPartial(object: import("../helpers").DeepPartial<_60.PreconditionFailure>): _60.PreconditionFailure;
+            fromAmino(object: _60.PreconditionFailureAmino): _60.PreconditionFailure;
+            toAmino(message: _60.PreconditionFailure): _60.PreconditionFailureAmino;
+            fromAminoMsg(object: _60.PreconditionFailureAminoMsg): _60.PreconditionFailure;
+            fromProtoMsg(message: _60.PreconditionFailureProtoMsg): _60.PreconditionFailure;
+            toProto(message: _60.PreconditionFailure): Uint8Array;
+            toProtoMsg(message: _60.PreconditionFailure): _60.PreconditionFailureProtoMsg;
+            registerTypeUrl(): void;
+        };
+        PreconditionFailure_Violation: {
+            typeUrl: string;
+            is(o: any): o is _60.PreconditionFailure_Violation;
+            isAmino(o: any): o is _60.PreconditionFailure_ViolationAmino;
+            encode(message: _60.PreconditionFailure_Violation, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _60.PreconditionFailure_Violation;
+            fromPartial(object: import("../helpers").DeepPartial<_60.PreconditionFailure_Violation>): _60.PreconditionFailure_Violation;
+            fromAmino(object: _60.PreconditionFailure_ViolationAmino): _60.PreconditionFailure_Violation;
+            toAmino(message: _60.PreconditionFailure_Violation): _60.PreconditionFailure_ViolationAmino;
+            fromAminoMsg(object: _60.PreconditionFailure_ViolationAminoMsg): _60.PreconditionFailure_Violation;
+            fromProtoMsg(message: _60.PreconditionFailure_ViolationProtoMsg): _60.PreconditionFailure_Violation;
+            toProto(message: _60.PreconditionFailure_Violation): Uint8Array;
+            toProtoMsg(message: _60.PreconditionFailure_Violation): _60.PreconditionFailure_ViolationProtoMsg;
+            registerTypeUrl(): void;
+        };
+        BadRequest: {
+            typeUrl: string;
+            is(o: any): o is _60.BadRequest;
+            isAmino(o: any): o is _60.BadRequestAmino;
+            encode(message: _60.BadRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _60.BadRequest;
+            fromPartial(object: import("../helpers").DeepPartial<_60.BadRequest>): _60.BadRequest;
+            fromAmino(object: _60.BadRequestAmino): _60.BadRequest;
+            toAmino(message: _60.BadRequest): _60.BadRequestAmino;
+            fromAminoMsg(object: _60.BadRequestAminoMsg): _60.BadRequest;
+            fromProtoMsg(message: _60.BadRequestProtoMsg): _60.BadRequest;
+            toProto(message: _60.BadRequest): Uint8Array;
+            toProtoMsg(message: _60.BadRequest): _60.BadRequestProtoMsg;
+            registerTypeUrl(): void;
+        };
+        BadRequest_FieldViolation: {
+            typeUrl: string;
+            is(o: any): o is _60.BadRequest_FieldViolation;
+            isAmino(o: any): o is _60.BadRequest_FieldViolationAmino;
+            encode(message: _60.BadRequest_FieldViolation, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _60.BadRequest_FieldViolation;
+            fromPartial(object: import("../helpers").DeepPartial<_60.BadRequest_FieldViolation>): _60.BadRequest_FieldViolation;
+            fromAmino(object: _60.BadRequest_FieldViolationAmino): _60.BadRequest_FieldViolation;
+            toAmino(message: _60.BadRequest_FieldViolation): _60.BadRequest_FieldViolationAmino;
+            fromAminoMsg(object: _60.BadRequest_FieldViolationAminoMsg): _60.BadRequest_FieldViolation;
+            fromProtoMsg(message: _60.BadRequest_FieldViolationProtoMsg): _60.BadRequest_FieldViolation;
+            toProto(message: _60.BadRequest_FieldViolation): Uint8Array;
+            toProtoMsg(message: _60.BadRequest_FieldViolation): _60.BadRequest_FieldViolationProtoMsg;
+            registerTypeUrl(): void;
+        };
+        RequestInfo: {
+            typeUrl: string;
+            is(o: any): o is _60.RequestInfo;
+            isAmino(o: any): o is _60.RequestInfoAmino;
+            encode(message: _60.RequestInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _60.RequestInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_60.RequestInfo>): _60.RequestInfo;
+            fromAmino(object: _60.RequestInfoAmino): _60.RequestInfo;
+            toAmino(message: _60.RequestInfo): _60.RequestInfoAmino;
+            fromAminoMsg(object: _60.RequestInfoAminoMsg): _60.RequestInfo;
+            fromProtoMsg(message: _60.RequestInfoProtoMsg): _60.RequestInfo;
+            toProto(message: _60.RequestInfo): Uint8Array;
+            toProtoMsg(message: _60.RequestInfo): _60.RequestInfoProtoMsg;
+            registerTypeUrl(): void;
+        };
+        ResourceInfo: {
+            typeUrl: string;
+            is(o: any): o is _60.ResourceInfo;
+            isAmino(o: any): o is _60.ResourceInfoAmino;
+            encode(message: _60.ResourceInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _60.ResourceInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_60.ResourceInfo>): _60.ResourceInfo;
+            fromAmino(object: _60.ResourceInfoAmino): _60.ResourceInfo;
+            toAmino(message: _60.ResourceInfo): _60.ResourceInfoAmino;
+            fromAminoMsg(object: _60.ResourceInfoAminoMsg): _60.ResourceInfo;
+            fromProtoMsg(message: _60.ResourceInfoProtoMsg): _60.ResourceInfo;
+            toProto(message: _60.ResourceInfo): Uint8Array;
+            toProtoMsg(message: _60.ResourceInfo): _60.ResourceInfoProtoMsg;
+            registerTypeUrl(): void;
+        };
+        Help: {
+            typeUrl: string;
+            is(o: any): o is _60.Help;
+            isAmino(o: any): o is _60.HelpAmino;
+            encode(message: _60.Help, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _60.Help;
+            fromPartial(object: import("../helpers").DeepPartial<_60.Help>): _60.Help;
+            fromAmino(object: _60.HelpAmino): _60.Help;
+            toAmino(message: _60.Help): _60.HelpAmino;
+            fromAminoMsg(object: _60.HelpAminoMsg): _60.Help;
+            fromProtoMsg(message: _60.HelpProtoMsg): _60.Help;
+            toProto(message: _60.Help): Uint8Array;
+            toProtoMsg(message: _60.Help): _60.HelpProtoMsg;
+            registerTypeUrl(): void;
+        };
+        Help_Link: {
+            typeUrl: string;
+            is(o: any): o is _60.Help_Link;
+            isAmino(o: any): o is _60.Help_LinkAmino;
+            encode(message: _60.Help_Link, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _60.Help_Link;
+            fromPartial(object: import("../helpers").DeepPartial<_60.Help_Link>): _60.Help_Link;
+            fromAmino(object: _60.Help_LinkAmino): _60.Help_Link;
+            toAmino(message: _60.Help_Link): _60.Help_LinkAmino;
+            fromAminoMsg(object: _60.Help_LinkAminoMsg): _60.Help_Link;
+            fromProtoMsg(message: _60.Help_LinkProtoMsg): _60.Help_Link;
+            toProto(message: _60.Help_Link): Uint8Array;
+            toProtoMsg(message: _60.Help_Link): _60.Help_LinkProtoMsg;
+            registerTypeUrl(): void;
+        };
+        LocalizedMessage: {
+            typeUrl: string;
+            is(o: any): o is _60.LocalizedMessage;
+            isAmino(o: any): o is _60.LocalizedMessageAmino;
+            encode(message: _60.LocalizedMessage, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _60.LocalizedMessage;
+            fromPartial(object: import("../helpers").DeepPartial<_60.LocalizedMessage>): _60.LocalizedMessage;
+            fromAmino(object: _60.LocalizedMessageAmino): _60.LocalizedMessage;
+            toAmino(message: _60.LocalizedMessage): _60.LocalizedMessageAmino;
+            fromAminoMsg(object: _60.LocalizedMessageAminoMsg): _60.LocalizedMessage;
+            fromProtoMsg(message: _60.LocalizedMessageProtoMsg): _60.LocalizedMessage;
+            toProto(message: _60.LocalizedMessage): Uint8Array;
+            toProtoMsg(message: _60.LocalizedMessage): _60.LocalizedMessageProtoMsg;
+            registerTypeUrl(): void;
+        };
+        Status: {
+            typeUrl: string;
+            is(o: any): o is _59.Status;
+            isAmino(o: any): o is _59.StatusAmino;
+            encode(message: _59.Status, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _59.Status;
+            fromPartial(object: import("../helpers").DeepPartial<_59.Status>): _59.Status;
+            fromAmino(object: _59.StatusAmino): _59.Status;
+            toAmino(message: _59.Status): _59.StatusAmino;
+            fromAminoMsg(object: _59.StatusAminoMsg): _59.Status;
+            fromProtoMsg(message: _59.StatusProtoMsg): _59.Status;
+            toProto(message: _59.Status): Uint8Array;
+            toProtoMsg(message: _59.Status): _59.StatusProtoMsg;
+            registerTypeUrl(): void;
+        };
+    };
+    const protobuf: {
+        FieldMask: {
+            typeUrl: string;
+            is(o: any): o is _69.FieldMask;
+            isAmino(o: any): o is _69.FieldMaskAmino;
+            encode(message: _69.FieldMask, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _69.FieldMask;
+            fromPartial(object: import("../helpers").DeepPartial<_69.FieldMask>): _69.FieldMask;
+            fromAmino(object: _69.FieldMaskAmino): _69.FieldMask;
+            toAmino(message: _69.FieldMask): _69.FieldMaskAmino;
+            fromAminoMsg(object: _69.FieldMaskAminoMsg): _69.FieldMask;
+            fromProtoMsg(message: _69.FieldMaskProtoMsg): _69.FieldMask;
+            toProto(message: _69.FieldMask): Uint8Array;
+            toProtoMsg(message: _69.FieldMask): _69.FieldMaskProtoMsg;
+            registerTypeUrl(): void;
+        };
+        Empty: {
+            typeUrl: string;
+            is(o: any): o is _68.Empty;
+            isAmino(o: any): o is _68.EmptyAmino;
+            encode(_: _68.Empty, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _68.Empty;
+            fromPartial(_: import("../helpers").DeepPartial<_68.Empty>): _68.Empty;
+            fromAmino(_: _68.EmptyAmino): _68.Empty;
+            toAmino(_: _68.Empty): _68.EmptyAmino;
+            fromAminoMsg(object: _68.EmptyAminoMsg): _68.Empty;
+            fromProtoMsg(message: _68.EmptyProtoMsg): _68.Empty;
+            toProto(message: _68.Empty): Uint8Array;
+            toProtoMsg(message: _68.Empty): _68.EmptyProtoMsg;
+            registerTypeUrl(): void;
+        };
+        nullValueFromJSON(object: any): _67.NullValue;
+        nullValueToJSON(object: _67.NullValue): string;
+        NullValue: typeof _67.NullValue;
+        NullValueAmino: typeof _67.NullValue;
+        Struct_FieldsEntry: {
+            encode(message: _67.Struct_FieldsEntry, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _67.Struct_FieldsEntry;
+            fromPartial(object: import("../helpers").DeepPartial<_67.Struct_FieldsEntry>): _67.Struct_FieldsEntry;
+            fromAmino(object: _67.Struct_FieldsEntryAmino): _67.Struct_FieldsEntry;
+            toAmino(message: _67.Struct_FieldsEntry): _67.Struct_FieldsEntryAmino;
+            fromAminoMsg(object: _67.Struct_FieldsEntryAminoMsg): _67.Struct_FieldsEntry;
+            fromProtoMsg(message: _67.Struct_FieldsEntryProtoMsg): _67.Struct_FieldsEntry;
+            toProto(message: _67.Struct_FieldsEntry): Uint8Array;
+            registerTypeUrl(): void;
+        };
+        Struct: {
+            typeUrl: string;
+            is(o: any): o is _67.Struct;
+            isAmino(o: any): o is _67.StructAmino;
+            encode(message: _67.Struct, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _67.Struct;
+            fromPartial(object: import("../helpers").DeepPartial<_67.Struct>): _67.Struct;
+            fromAmino(object: _67.StructAmino): _67.Struct;
+            toAmino(message: _67.Struct): _67.StructAmino;
+            fromAminoMsg(object: _67.StructAminoMsg): _67.Struct;
+            fromProtoMsg(message: _67.StructProtoMsg): _67.Struct;
+            toProto(message: _67.Struct): Uint8Array;
+            toProtoMsg(message: _67.Struct): _67.StructProtoMsg;
+            registerTypeUrl(): void;
+        };
+        Value: {
+            typeUrl: string;
+            is(o: any): o is _67.Value;
+            isAmino(o: any): o is _67.ValueAmino;
+            encode(message: _67.Value, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _67.Value;
+            fromPartial(object: import("../helpers").DeepPartial<_67.Value>): _67.Value;
+            fromAmino(object: _67.ValueAmino): _67.Value;
+            toAmino(message: _67.Value): _67.ValueAmino;
+            fromAminoMsg(object: _67.ValueAminoMsg): _67.Value;
+            fromProtoMsg(message: _67.ValueProtoMsg): _67.Value;
+            toProto(message: _67.Value): Uint8Array;
+            toProtoMsg(message: _67.Value): _67.ValueProtoMsg;
+            registerTypeUrl(): void;
+        };
+        ListValue: {
+            typeUrl: string;
+            is(o: any): o is _67.ListValue;
+            isAmino(o: any): o is _67.ListValueAmino;
+            encode(message: _67.ListValue, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _67.ListValue;
+            fromPartial(object: import("../helpers").DeepPartial<_67.ListValue>): _67.ListValue;
+            fromAmino(object: _67.ListValueAmino): _67.ListValue;
+            toAmino(message: _67.ListValue): _67.ListValueAmino;
+            fromAminoMsg(object: _67.ListValueAminoMsg): _67.ListValue;
+            fromProtoMsg(message: _67.ListValueProtoMsg): _67.ListValue;
+            toProto(message: _67.ListValue): Uint8Array;
+            toProtoMsg(message: _67.ListValue): _67.ListValueProtoMsg;
+            registerTypeUrl(): void;
+        };
+        Any: {
+            typeUrl: string;
+            is(o: any): o is _66.Any;
+            isAmino(o: any): o is _66.AnyAmino;
+            encode(message: _66.Any, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _66.Any;
+            fromPartial(object: import("../helpers").DeepPartial<_66.Any>): _66.Any;
+            fromAmino(object: _66.AnyAmino): _66.Any;
+            toAmino(message: _66.Any): _66.AnyAmino;
+            fromAminoMsg(object: _66.AnyAminoMsg): _66.Any;
+            fromProtoMsg(message: _66.AnyProtoMsg): _66.Any;
+            toProto(message: _66.Any): Uint8Array;
+            toProtoMsg(message: _66.Any): _66.AnyProtoMsg;
+            registerTypeUrl(): void;
+        };
+        DoubleValue: {
+            typeUrl: string;
+            is(o: any): o is _65.DoubleValue;
+            isAmino(o: any): o is _65.DoubleValueAmino;
+            encode(message: _65.DoubleValue, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _65.DoubleValue;
+            fromPartial(object: import("../helpers").DeepPartial<_65.DoubleValue>): _65.DoubleValue;
+            fromAmino(object: _65.DoubleValueAmino): _65.DoubleValue;
+            toAmino(message: _65.DoubleValue): _65.DoubleValueAmino;
+            fromAminoMsg(object: _65.DoubleValueAminoMsg): _65.DoubleValue;
+            fromProtoMsg(message: _65.DoubleValueProtoMsg): _65.DoubleValue;
+            toProto(message: _65.DoubleValue): Uint8Array;
+            toProtoMsg(message: _65.DoubleValue): _65.DoubleValueProtoMsg;
+            registerTypeUrl(): void;
+        };
+        FloatValue: {
+            typeUrl: string;
+            is(o: any): o is _65.FloatValue;
+            isAmino(o: any): o is _65.FloatValueAmino;
+            encode(message: _65.FloatValue, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _65.FloatValue;
+            fromPartial(object: import("../helpers").DeepPartial<_65.FloatValue>): _65.FloatValue;
+            fromAmino(object: _65.FloatValueAmino): _65.FloatValue;
+            toAmino(message: _65.FloatValue): _65.FloatValueAmino;
+            fromAminoMsg(object: _65.FloatValueAminoMsg): _65.FloatValue;
+            fromProtoMsg(message: _65.FloatValueProtoMsg): _65.FloatValue;
+            toProto(message: _65.FloatValue): Uint8Array;
+            toProtoMsg(message: _65.FloatValue): _65.FloatValueProtoMsg;
+            registerTypeUrl(): void;
+        };
+        Int64Value: {
+            typeUrl: string;
+            is(o: any): o is _65.Int64Value;
+            isAmino(o: any): o is _65.Int64ValueAmino;
+            encode(message: _65.Int64Value, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _65.Int64Value;
+            fromPartial(object: import("../helpers").DeepPartial<_65.Int64Value>): _65.Int64Value;
+            fromAmino(object: _65.Int64ValueAmino): _65.Int64Value;
+            toAmino(message: _65.Int64Value): _65.Int64ValueAmino;
+            fromAminoMsg(object: _65.Int64ValueAminoMsg): _65.Int64Value;
+            fromProtoMsg(message: _65.Int64ValueProtoMsg): _65.Int64Value;
+            toProto(message: _65.Int64Value): Uint8Array;
+            toProtoMsg(message: _65.Int64Value): _65.Int64ValueProtoMsg;
+            registerTypeUrl(): void;
+        };
+        UInt64Value: {
+            typeUrl: string;
+            is(o: any): o is _65.UInt64Value;
+            isAmino(o: any): o is _65.UInt64ValueAmino;
+            encode(message: _65.UInt64Value, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _65.UInt64Value;
+            fromPartial(object: import("../helpers").DeepPartial<_65.UInt64Value>): _65.UInt64Value;
+            fromAmino(object: _65.UInt64ValueAmino): _65.UInt64Value;
+            toAmino(message: _65.UInt64Value): _65.UInt64ValueAmino;
+            fromAminoMsg(object: _65.UInt64ValueAminoMsg): _65.UInt64Value;
+            fromProtoMsg(message: _65.UInt64ValueProtoMsg): _65.UInt64Value;
+            toProto(message: _65.UInt64Value): Uint8Array;
+            toProtoMsg(message: _65.UInt64Value): _65.UInt64ValueProtoMsg;
+            registerTypeUrl(): void;
+        };
+        Int32Value: {
+            typeUrl: string;
+            is(o: any): o is _65.Int32Value;
+            isAmino(o: any): o is _65.Int32ValueAmino;
+            encode(message: _65.Int32Value, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _65.Int32Value;
+            fromPartial(object: import("../helpers").DeepPartial<_65.Int32Value>): _65.Int32Value;
+            fromAmino(object: _65.Int32ValueAmino): _65.Int32Value;
+            toAmino(message: _65.Int32Value): _65.Int32ValueAmino;
+            fromAminoMsg(object: _65.Int32ValueAminoMsg): _65.Int32Value;
+            fromProtoMsg(message: _65.Int32ValueProtoMsg): _65.Int32Value;
+            toProto(message: _65.Int32Value): Uint8Array;
+            toProtoMsg(message: _65.Int32Value): _65.Int32ValueProtoMsg;
+            registerTypeUrl(): void;
+        };
+        UInt32Value: {
+            typeUrl: string;
+            is(o: any): o is _65.UInt32Value;
+            isAmino(o: any): o is _65.UInt32ValueAmino;
+            encode(message: _65.UInt32Value, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _65.UInt32Value;
+            fromPartial(object: import("../helpers").DeepPartial<_65.UInt32Value>): _65.UInt32Value;
+            fromAmino(object: _65.UInt32ValueAmino): _65.UInt32Value;
+            toAmino(message: _65.UInt32Value): _65.UInt32ValueAmino;
+            fromAminoMsg(object: _65.UInt32ValueAminoMsg): _65.UInt32Value;
+            fromProtoMsg(message: _65.UInt32ValueProtoMsg): _65.UInt32Value;
+            toProto(message: _65.UInt32Value): Uint8Array;
+            toProtoMsg(message: _65.UInt32Value): _65.UInt32ValueProtoMsg;
+            registerTypeUrl(): void;
+        };
+        BoolValue: {
+            typeUrl: string;
+            is(o: any): o is _65.BoolValue;
+            isAmino(o: any): o is _65.BoolValueAmino;
+            encode(message: _65.BoolValue, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _65.BoolValue;
+            fromPartial(object: import("../helpers").DeepPartial<_65.BoolValue>): _65.BoolValue;
+            fromAmino(object: _65.BoolValueAmino): _65.BoolValue;
+            toAmino(message: _65.BoolValue): _65.BoolValueAmino;
+            fromAminoMsg(object: _65.BoolValueAminoMsg): _65.BoolValue;
+            fromProtoMsg(message: _65.BoolValueProtoMsg): _65.BoolValue;
+            toProto(message: _65.BoolValue): Uint8Array;
+            toProtoMsg(message: _65.BoolValue): _65.BoolValueProtoMsg;
+            registerTypeUrl(): void;
+        };
+        StringValue: {
+            typeUrl: string;
+            is(o: any): o is _65.StringValue;
+            isAmino(o: any): o is _65.StringValueAmino;
+            encode(message: _65.StringValue, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _65.StringValue;
+            fromPartial(object: import("../helpers").DeepPartial<_65.StringValue>): _65.StringValue;
+            fromAmino(object: _65.StringValueAmino): _65.StringValue;
+            toAmino(message: _65.StringValue): _65.StringValueAmino;
+            fromAminoMsg(object: _65.StringValueAminoMsg): _65.StringValue;
+            fromProtoMsg(message: _65.StringValueProtoMsg): _65.StringValue;
+            toProto(message: _65.StringValue): Uint8Array;
+            toProtoMsg(message: _65.StringValue): _65.StringValueProtoMsg;
+            registerTypeUrl(): void;
+        };
+        BytesValue: {
+            typeUrl: string;
+            is(o: any): o is _65.BytesValue;
+            isAmino(o: any): o is _65.BytesValueAmino;
+            encode(message: _65.BytesValue, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _65.BytesValue;
+            fromPartial(object: import("../helpers").DeepPartial<_65.BytesValue>): _65.BytesValue;
+            fromAmino(object: _65.BytesValueAmino): _65.BytesValue;
+            toAmino(message: _65.BytesValue): _65.BytesValueAmino;
+            fromAminoMsg(object: _65.BytesValueAminoMsg): _65.BytesValue;
+            fromProtoMsg(message: _65.BytesValueProtoMsg): _65.BytesValue;
+            toProto(message: _65.BytesValue): Uint8Array;
+            toProtoMsg(message: _65.BytesValue): _65.BytesValueProtoMsg;
+            registerTypeUrl(): void;
+        };
+        editionFromJSON(object: any): _64.Edition;
+        editionToJSON(object: _64.Edition): string;
+        extensionRangeOptions_VerificationStateFromJSON(object: any): _64.ExtensionRangeOptions_VerificationState;
+        extensionRangeOptions_VerificationStateToJSON(object: _64.ExtensionRangeOptions_VerificationState): string;
+        fieldDescriptorProto_TypeFromJSON(object: any): _64.FieldDescriptorProto_Type;
+        fieldDescriptorProto_TypeToJSON(object: _64.FieldDescriptorProto_Type): string;
+        fieldDescriptorProto_LabelFromJSON(object: any): _64.FieldDescriptorProto_Label;
+        fieldDescriptorProto_LabelToJSON(object: _64.FieldDescriptorProto_Label): string;
+        fileOptions_OptimizeModeFromJSON(object: any): _64.FileOptions_OptimizeMode;
+        fileOptions_OptimizeModeToJSON(object: _64.FileOptions_OptimizeMode): string;
+        fieldOptions_CTypeFromJSON(object: any): _64.FieldOptions_CType;
+        fieldOptions_CTypeToJSON(object: _64.FieldOptions_CType): string;
+        fieldOptions_JSTypeFromJSON(object: any): _64.FieldOptions_JSType;
+        fieldOptions_JSTypeToJSON(object: _64.FieldOptions_JSType): string;
+        fieldOptions_OptionRetentionFromJSON(object: any): _64.FieldOptions_OptionRetention;
+        fieldOptions_OptionRetentionToJSON(object: _64.FieldOptions_OptionRetention): string;
+        fieldOptions_OptionTargetTypeFromJSON(object: any): _64.FieldOptions_OptionTargetType;
+        fieldOptions_OptionTargetTypeToJSON(object: _64.FieldOptions_OptionTargetType): string;
+        methodOptions_IdempotencyLevelFromJSON(object: any): _64.MethodOptions_IdempotencyLevel;
+        methodOptions_IdempotencyLevelToJSON(object: _64.MethodOptions_IdempotencyLevel): string;
+        featureSet_FieldPresenceFromJSON(object: any): _64.FeatureSet_FieldPresence;
+        featureSet_FieldPresenceToJSON(object: _64.FeatureSet_FieldPresence): string;
+        featureSet_EnumTypeFromJSON(object: any): _64.FeatureSet_EnumType;
+        featureSet_EnumTypeToJSON(object: _64.FeatureSet_EnumType): string;
+        featureSet_RepeatedFieldEncodingFromJSON(object: any): _64.FeatureSet_RepeatedFieldEncoding;
+        featureSet_RepeatedFieldEncodingToJSON(object: _64.FeatureSet_RepeatedFieldEncoding): string;
+        featureSet_Utf8ValidationFromJSON(object: any): _64.FeatureSet_Utf8Validation;
+        featureSet_Utf8ValidationToJSON(object: _64.FeatureSet_Utf8Validation): string;
+        featureSet_MessageEncodingFromJSON(object: any): _64.FeatureSet_MessageEncoding;
+        featureSet_MessageEncodingToJSON(object: _64.FeatureSet_MessageEncoding): string;
+        featureSet_JsonFormatFromJSON(object: any): _64.FeatureSet_JsonFormat;
+        featureSet_JsonFormatToJSON(object: _64.FeatureSet_JsonFormat): string;
+        featureSet_EnforceNamingStyleFromJSON(object: any): _64.FeatureSet_EnforceNamingStyle;
+        featureSet_EnforceNamingStyleToJSON(object: _64.FeatureSet_EnforceNamingStyle): string;
+        featureSet_VisibilityFeature_DefaultSymbolVisibilityFromJSON(object: any): _64.FeatureSet_VisibilityFeature_DefaultSymbolVisibility;
+        featureSet_VisibilityFeature_DefaultSymbolVisibilityToJSON(object: _64.FeatureSet_VisibilityFeature_DefaultSymbolVisibility): string;
+        generatedCodeInfo_Annotation_SemanticFromJSON(object: any): _64.GeneratedCodeInfo_Annotation_Semantic;
+        generatedCodeInfo_Annotation_SemanticToJSON(object: _64.GeneratedCodeInfo_Annotation_Semantic): string;
+        symbolVisibilityFromJSON(object: any): _64.SymbolVisibility;
+        symbolVisibilityToJSON(object: _64.SymbolVisibility): string;
+        Edition: typeof _64.Edition;
+        EditionAmino: typeof _64.Edition;
+        ExtensionRangeOptions_VerificationState: typeof _64.ExtensionRangeOptions_VerificationState;
+        ExtensionRangeOptions_VerificationStateAmino: typeof _64.ExtensionRangeOptions_VerificationState;
+        FieldDescriptorProto_Type: typeof _64.FieldDescriptorProto_Type;
+        FieldDescriptorProto_TypeAmino: typeof _64.FieldDescriptorProto_Type;
+        FieldDescriptorProto_Label: typeof _64.FieldDescriptorProto_Label;
+        FieldDescriptorProto_LabelAmino: typeof _64.FieldDescriptorProto_Label;
+        FileOptions_OptimizeMode: typeof _64.FileOptions_OptimizeMode;
+        FileOptions_OptimizeModeAmino: typeof _64.FileOptions_OptimizeMode;
+        FieldOptions_CType: typeof _64.FieldOptions_CType;
+        FieldOptions_CTypeAmino: typeof _64.FieldOptions_CType;
+        FieldOptions_JSType: typeof _64.FieldOptions_JSType;
+        FieldOptions_JSTypeAmino: typeof _64.FieldOptions_JSType;
+        FieldOptions_OptionRetention: typeof _64.FieldOptions_OptionRetention;
+        FieldOptions_OptionRetentionAmino: typeof _64.FieldOptions_OptionRetention;
+        FieldOptions_OptionTargetType: typeof _64.FieldOptions_OptionTargetType;
+        FieldOptions_OptionTargetTypeAmino: typeof _64.FieldOptions_OptionTargetType;
+        MethodOptions_IdempotencyLevel: typeof _64.MethodOptions_IdempotencyLevel;
+        MethodOptions_IdempotencyLevelAmino: typeof _64.MethodOptions_IdempotencyLevel;
+        FeatureSet_FieldPresence: typeof _64.FeatureSet_FieldPresence;
+        FeatureSet_FieldPresenceAmino: typeof _64.FeatureSet_FieldPresence;
+        FeatureSet_EnumType: typeof _64.FeatureSet_EnumType;
+        FeatureSet_EnumTypeAmino: typeof _64.FeatureSet_EnumType;
+        FeatureSet_RepeatedFieldEncoding: typeof _64.FeatureSet_RepeatedFieldEncoding;
+        FeatureSet_RepeatedFieldEncodingAmino: typeof _64.FeatureSet_RepeatedFieldEncoding;
+        FeatureSet_Utf8Validation: typeof _64.FeatureSet_Utf8Validation;
+        FeatureSet_Utf8ValidationAmino: typeof _64.FeatureSet_Utf8Validation;
+        FeatureSet_MessageEncoding: typeof _64.FeatureSet_MessageEncoding;
+        FeatureSet_MessageEncodingAmino: typeof _64.FeatureSet_MessageEncoding;
+        FeatureSet_JsonFormat: typeof _64.FeatureSet_JsonFormat;
+        FeatureSet_JsonFormatAmino: typeof _64.FeatureSet_JsonFormat;
+        FeatureSet_EnforceNamingStyle: typeof _64.FeatureSet_EnforceNamingStyle;
+        FeatureSet_EnforceNamingStyleAmino: typeof _64.FeatureSet_EnforceNamingStyle;
+        FeatureSet_VisibilityFeature_DefaultSymbolVisibility: typeof _64.FeatureSet_VisibilityFeature_DefaultSymbolVisibility;
+        FeatureSet_VisibilityFeature_DefaultSymbolVisibilityAmino: typeof _64.FeatureSet_VisibilityFeature_DefaultSymbolVisibility;
+        GeneratedCodeInfo_Annotation_Semantic: typeof _64.GeneratedCodeInfo_Annotation_Semantic;
+        GeneratedCodeInfo_Annotation_SemanticAmino: typeof _64.GeneratedCodeInfo_Annotation_Semantic;
+        SymbolVisibility: typeof _64.SymbolVisibility;
+        SymbolVisibilityAmino: typeof _64.SymbolVisibility;
+        FileDescriptorSet: {
+            typeUrl: string;
+            is(o: any): o is _64.FileDescriptorSet;
+            isAmino(o: any): o is _64.FileDescriptorSetAmino;
+            encode(message: _64.FileDescriptorSet, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.FileDescriptorSet;
+            fromPartial(object: import("../helpers").DeepPartial<_64.FileDescriptorSet>): _64.FileDescriptorSet;
+            fromAmino(object: _64.FileDescriptorSetAmino): _64.FileDescriptorSet;
+            toAmino(message: _64.FileDescriptorSet): _64.FileDescriptorSetAmino;
+            fromAminoMsg(object: _64.FileDescriptorSetAminoMsg): _64.FileDescriptorSet;
+            fromProtoMsg(message: _64.FileDescriptorSetProtoMsg): _64.FileDescriptorSet;
+            toProto(message: _64.FileDescriptorSet): Uint8Array;
+            toProtoMsg(message: _64.FileDescriptorSet): _64.FileDescriptorSetProtoMsg;
+            registerTypeUrl(): void;
+        };
+        FileDescriptorProto: {
+            typeUrl: string;
+            is(o: any): o is _64.FileDescriptorProto;
+            isAmino(o: any): o is _64.FileDescriptorProtoAmino;
+            encode(message: _64.FileDescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.FileDescriptorProto;
+            fromPartial(object: import("../helpers").DeepPartial<_64.FileDescriptorProto>): _64.FileDescriptorProto;
+            fromAmino(object: _64.FileDescriptorProtoAmino): _64.FileDescriptorProto;
+            toAmino(message: _64.FileDescriptorProto): _64.FileDescriptorProtoAmino;
+            fromAminoMsg(object: _64.FileDescriptorProtoAminoMsg): _64.FileDescriptorProto;
+            fromProtoMsg(message: _64.FileDescriptorProtoProtoMsg): _64.FileDescriptorProto;
+            toProto(message: _64.FileDescriptorProto): Uint8Array;
+            toProtoMsg(message: _64.FileDescriptorProto): _64.FileDescriptorProtoProtoMsg;
+            registerTypeUrl(): void;
+        };
+        DescriptorProto: {
+            typeUrl: string;
+            is(o: any): o is _64.DescriptorProto;
+            isAmino(o: any): o is _64.DescriptorProtoAmino;
+            encode(message: _64.DescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.DescriptorProto;
+            fromPartial(object: import("../helpers").DeepPartial<_64.DescriptorProto>): _64.DescriptorProto;
+            fromAmino(object: _64.DescriptorProtoAmino): _64.DescriptorProto;
+            toAmino(message: _64.DescriptorProto): _64.DescriptorProtoAmino;
+            fromAminoMsg(object: _64.DescriptorProtoAminoMsg): _64.DescriptorProto;
+            fromProtoMsg(message: _64.DescriptorProtoProtoMsg): _64.DescriptorProto;
+            toProto(message: _64.DescriptorProto): Uint8Array;
+            toProtoMsg(message: _64.DescriptorProto): _64.DescriptorProtoProtoMsg;
+            registerTypeUrl(): void;
+        };
+        DescriptorProto_ExtensionRange: {
+            typeUrl: string;
+            is(o: any): o is _64.DescriptorProto_ExtensionRange;
+            isAmino(o: any): o is _64.DescriptorProto_ExtensionRangeAmino;
+            encode(message: _64.DescriptorProto_ExtensionRange, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.DescriptorProto_ExtensionRange;
+            fromPartial(object: import("../helpers").DeepPartial<_64.DescriptorProto_ExtensionRange>): _64.DescriptorProto_ExtensionRange;
+            fromAmino(object: _64.DescriptorProto_ExtensionRangeAmino): _64.DescriptorProto_ExtensionRange;
+            toAmino(message: _64.DescriptorProto_ExtensionRange): _64.DescriptorProto_ExtensionRangeAmino;
+            fromAminoMsg(object: _64.DescriptorProto_ExtensionRangeAminoMsg): _64.DescriptorProto_ExtensionRange;
+            fromProtoMsg(message: _64.DescriptorProto_ExtensionRangeProtoMsg): _64.DescriptorProto_ExtensionRange;
+            toProto(message: _64.DescriptorProto_ExtensionRange): Uint8Array;
+            toProtoMsg(message: _64.DescriptorProto_ExtensionRange): _64.DescriptorProto_ExtensionRangeProtoMsg;
+            registerTypeUrl(): void;
+        };
+        DescriptorProto_ReservedRange: {
+            typeUrl: string;
+            is(o: any): o is _64.DescriptorProto_ReservedRange;
+            isAmino(o: any): o is _64.DescriptorProto_ReservedRangeAmino;
+            encode(message: _64.DescriptorProto_ReservedRange, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.DescriptorProto_ReservedRange;
+            fromPartial(object: import("../helpers").DeepPartial<_64.DescriptorProto_ReservedRange>): _64.DescriptorProto_ReservedRange;
+            fromAmino(object: _64.DescriptorProto_ReservedRangeAmino): _64.DescriptorProto_ReservedRange;
+            toAmino(message: _64.DescriptorProto_ReservedRange): _64.DescriptorProto_ReservedRangeAmino;
+            fromAminoMsg(object: _64.DescriptorProto_ReservedRangeAminoMsg): _64.DescriptorProto_ReservedRange;
+            fromProtoMsg(message: _64.DescriptorProto_ReservedRangeProtoMsg): _64.DescriptorProto_ReservedRange;
+            toProto(message: _64.DescriptorProto_ReservedRange): Uint8Array;
+            toProtoMsg(message: _64.DescriptorProto_ReservedRange): _64.DescriptorProto_ReservedRangeProtoMsg;
+            registerTypeUrl(): void;
+        };
+        ExtensionRangeOptions: {
+            typeUrl: string;
+            is(o: any): o is _64.ExtensionRangeOptions;
+            isAmino(o: any): o is _64.ExtensionRangeOptionsAmino;
+            encode(message: _64.ExtensionRangeOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.ExtensionRangeOptions;
+            fromPartial(object: import("../helpers").DeepPartial<_64.ExtensionRangeOptions>): _64.ExtensionRangeOptions;
+            fromAmino(object: _64.ExtensionRangeOptionsAmino): _64.ExtensionRangeOptions;
+            toAmino(message: _64.ExtensionRangeOptions): _64.ExtensionRangeOptionsAmino;
+            fromAminoMsg(object: _64.ExtensionRangeOptionsAminoMsg): _64.ExtensionRangeOptions;
+            fromProtoMsg(message: _64.ExtensionRangeOptionsProtoMsg): _64.ExtensionRangeOptions;
+            toProto(message: _64.ExtensionRangeOptions): Uint8Array;
+            toProtoMsg(message: _64.ExtensionRangeOptions): _64.ExtensionRangeOptionsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        ExtensionRangeOptions_Declaration: {
+            typeUrl: string;
+            is(o: any): o is _64.ExtensionRangeOptions_Declaration;
+            isAmino(o: any): o is _64.ExtensionRangeOptions_DeclarationAmino;
+            encode(message: _64.ExtensionRangeOptions_Declaration, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.ExtensionRangeOptions_Declaration;
+            fromPartial(object: import("../helpers").DeepPartial<_64.ExtensionRangeOptions_Declaration>): _64.ExtensionRangeOptions_Declaration;
+            fromAmino(object: _64.ExtensionRangeOptions_DeclarationAmino): _64.ExtensionRangeOptions_Declaration;
+            toAmino(message: _64.ExtensionRangeOptions_Declaration): _64.ExtensionRangeOptions_DeclarationAmino;
+            fromAminoMsg(object: _64.ExtensionRangeOptions_DeclarationAminoMsg): _64.ExtensionRangeOptions_Declaration;
+            fromProtoMsg(message: _64.ExtensionRangeOptions_DeclarationProtoMsg): _64.ExtensionRangeOptions_Declaration;
+            toProto(message: _64.ExtensionRangeOptions_Declaration): Uint8Array;
+            toProtoMsg(message: _64.ExtensionRangeOptions_Declaration): _64.ExtensionRangeOptions_DeclarationProtoMsg;
+            registerTypeUrl(): void;
+        };
+        FieldDescriptorProto: {
+            typeUrl: string;
+            is(o: any): o is _64.FieldDescriptorProto;
+            isAmino(o: any): o is _64.FieldDescriptorProtoAmino;
+            encode(message: _64.FieldDescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.FieldDescriptorProto;
+            fromPartial(object: import("../helpers").DeepPartial<_64.FieldDescriptorProto>): _64.FieldDescriptorProto;
+            fromAmino(object: _64.FieldDescriptorProtoAmino): _64.FieldDescriptorProto;
+            toAmino(message: _64.FieldDescriptorProto): _64.FieldDescriptorProtoAmino;
+            fromAminoMsg(object: _64.FieldDescriptorProtoAminoMsg): _64.FieldDescriptorProto;
+            fromProtoMsg(message: _64.FieldDescriptorProtoProtoMsg): _64.FieldDescriptorProto;
+            toProto(message: _64.FieldDescriptorProto): Uint8Array;
+            toProtoMsg(message: _64.FieldDescriptorProto): _64.FieldDescriptorProtoProtoMsg;
+            registerTypeUrl(): void;
+        };
+        OneofDescriptorProto: {
+            typeUrl: string;
+            is(o: any): o is _64.OneofDescriptorProto;
+            isAmino(o: any): o is _64.OneofDescriptorProtoAmino;
+            encode(message: _64.OneofDescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.OneofDescriptorProto;
+            fromPartial(object: import("../helpers").DeepPartial<_64.OneofDescriptorProto>): _64.OneofDescriptorProto;
+            fromAmino(object: _64.OneofDescriptorProtoAmino): _64.OneofDescriptorProto;
+            toAmino(message: _64.OneofDescriptorProto): _64.OneofDescriptorProtoAmino;
+            fromAminoMsg(object: _64.OneofDescriptorProtoAminoMsg): _64.OneofDescriptorProto;
+            fromProtoMsg(message: _64.OneofDescriptorProtoProtoMsg): _64.OneofDescriptorProto;
+            toProto(message: _64.OneofDescriptorProto): Uint8Array;
+            toProtoMsg(message: _64.OneofDescriptorProto): _64.OneofDescriptorProtoProtoMsg;
+            registerTypeUrl(): void;
+        };
+        EnumDescriptorProto: {
+            typeUrl: string;
+            is(o: any): o is _64.EnumDescriptorProto;
+            isAmino(o: any): o is _64.EnumDescriptorProtoAmino;
+            encode(message: _64.EnumDescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.EnumDescriptorProto;
+            fromPartial(object: import("../helpers").DeepPartial<_64.EnumDescriptorProto>): _64.EnumDescriptorProto;
+            fromAmino(object: _64.EnumDescriptorProtoAmino): _64.EnumDescriptorProto;
+            toAmino(message: _64.EnumDescriptorProto): _64.EnumDescriptorProtoAmino;
+            fromAminoMsg(object: _64.EnumDescriptorProtoAminoMsg): _64.EnumDescriptorProto;
+            fromProtoMsg(message: _64.EnumDescriptorProtoProtoMsg): _64.EnumDescriptorProto;
+            toProto(message: _64.EnumDescriptorProto): Uint8Array;
+            toProtoMsg(message: _64.EnumDescriptorProto): _64.EnumDescriptorProtoProtoMsg;
+            registerTypeUrl(): void;
+        };
+        EnumDescriptorProto_EnumReservedRange: {
+            typeUrl: string;
+            is(o: any): o is _64.EnumDescriptorProto_EnumReservedRange;
+            isAmino(o: any): o is _64.EnumDescriptorProto_EnumReservedRangeAmino;
+            encode(message: _64.EnumDescriptorProto_EnumReservedRange, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.EnumDescriptorProto_EnumReservedRange;
+            fromPartial(object: import("../helpers").DeepPartial<_64.EnumDescriptorProto_EnumReservedRange>): _64.EnumDescriptorProto_EnumReservedRange;
+            fromAmino(object: _64.EnumDescriptorProto_EnumReservedRangeAmino): _64.EnumDescriptorProto_EnumReservedRange;
+            toAmino(message: _64.EnumDescriptorProto_EnumReservedRange): _64.EnumDescriptorProto_EnumReservedRangeAmino;
+            fromAminoMsg(object: _64.EnumDescriptorProto_EnumReservedRangeAminoMsg): _64.EnumDescriptorProto_EnumReservedRange;
+            fromProtoMsg(message: _64.EnumDescriptorProto_EnumReservedRangeProtoMsg): _64.EnumDescriptorProto_EnumReservedRange;
+            toProto(message: _64.EnumDescriptorProto_EnumReservedRange): Uint8Array;
+            toProtoMsg(message: _64.EnumDescriptorProto_EnumReservedRange): _64.EnumDescriptorProto_EnumReservedRangeProtoMsg;
+            registerTypeUrl(): void;
+        };
+        EnumValueDescriptorProto: {
+            typeUrl: string;
+            is(o: any): o is _64.EnumValueDescriptorProto;
+            isAmino(o: any): o is _64.EnumValueDescriptorProtoAmino;
+            encode(message: _64.EnumValueDescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.EnumValueDescriptorProto;
+            fromPartial(object: import("../helpers").DeepPartial<_64.EnumValueDescriptorProto>): _64.EnumValueDescriptorProto;
+            fromAmino(object: _64.EnumValueDescriptorProtoAmino): _64.EnumValueDescriptorProto;
+            toAmino(message: _64.EnumValueDescriptorProto): _64.EnumValueDescriptorProtoAmino;
+            fromAminoMsg(object: _64.EnumValueDescriptorProtoAminoMsg): _64.EnumValueDescriptorProto;
+            fromProtoMsg(message: _64.EnumValueDescriptorProtoProtoMsg): _64.EnumValueDescriptorProto;
+            toProto(message: _64.EnumValueDescriptorProto): Uint8Array;
+            toProtoMsg(message: _64.EnumValueDescriptorProto): _64.EnumValueDescriptorProtoProtoMsg;
+            registerTypeUrl(): void;
+        };
+        ServiceDescriptorProto: {
+            typeUrl: string;
+            is(o: any): o is _64.ServiceDescriptorProto;
+            isAmino(o: any): o is _64.ServiceDescriptorProtoAmino;
+            encode(message: _64.ServiceDescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.ServiceDescriptorProto;
+            fromPartial(object: import("../helpers").DeepPartial<_64.ServiceDescriptorProto>): _64.ServiceDescriptorProto;
+            fromAmino(object: _64.ServiceDescriptorProtoAmino): _64.ServiceDescriptorProto;
+            toAmino(message: _64.ServiceDescriptorProto): _64.ServiceDescriptorProtoAmino;
+            fromAminoMsg(object: _64.ServiceDescriptorProtoAminoMsg): _64.ServiceDescriptorProto;
+            fromProtoMsg(message: _64.ServiceDescriptorProtoProtoMsg): _64.ServiceDescriptorProto;
+            toProto(message: _64.ServiceDescriptorProto): Uint8Array;
+            toProtoMsg(message: _64.ServiceDescriptorProto): _64.ServiceDescriptorProtoProtoMsg;
+            registerTypeUrl(): void;
+        };
+        MethodDescriptorProto: {
+            typeUrl: string;
+            is(o: any): o is _64.MethodDescriptorProto;
+            isAmino(o: any): o is _64.MethodDescriptorProtoAmino;
+            encode(message: _64.MethodDescriptorProto, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.MethodDescriptorProto;
+            fromPartial(object: import("../helpers").DeepPartial<_64.MethodDescriptorProto>): _64.MethodDescriptorProto;
+            fromAmino(object: _64.MethodDescriptorProtoAmino): _64.MethodDescriptorProto;
+            toAmino(message: _64.MethodDescriptorProto): _64.MethodDescriptorProtoAmino;
+            fromAminoMsg(object: _64.MethodDescriptorProtoAminoMsg): _64.MethodDescriptorProto;
+            fromProtoMsg(message: _64.MethodDescriptorProtoProtoMsg): _64.MethodDescriptorProto;
+            toProto(message: _64.MethodDescriptorProto): Uint8Array;
+            toProtoMsg(message: _64.MethodDescriptorProto): _64.MethodDescriptorProtoProtoMsg;
+            registerTypeUrl(): void;
+        };
+        FileOptions: {
+            typeUrl: string;
+            is(o: any): o is _64.FileOptions;
+            isAmino(o: any): o is _64.FileOptionsAmino;
+            encode(message: _64.FileOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.FileOptions;
+            fromPartial(object: import("../helpers").DeepPartial<_64.FileOptions>): _64.FileOptions;
+            fromAmino(object: _64.FileOptionsAmino): _64.FileOptions;
+            toAmino(message: _64.FileOptions): _64.FileOptionsAmino;
+            fromAminoMsg(object: _64.FileOptionsAminoMsg): _64.FileOptions;
+            fromProtoMsg(message: _64.FileOptionsProtoMsg): _64.FileOptions;
+            toProto(message: _64.FileOptions): Uint8Array;
+            toProtoMsg(message: _64.FileOptions): _64.FileOptionsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        MessageOptions: {
+            typeUrl: string;
+            is(o: any): o is _64.MessageOptions;
+            isAmino(o: any): o is _64.MessageOptionsAmino;
+            encode(message: _64.MessageOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.MessageOptions;
+            fromPartial(object: import("../helpers").DeepPartial<_64.MessageOptions>): _64.MessageOptions;
+            fromAmino(object: _64.MessageOptionsAmino): _64.MessageOptions;
+            toAmino(message: _64.MessageOptions): _64.MessageOptionsAmino;
+            fromAminoMsg(object: _64.MessageOptionsAminoMsg): _64.MessageOptions;
+            fromProtoMsg(message: _64.MessageOptionsProtoMsg): _64.MessageOptions;
+            toProto(message: _64.MessageOptions): Uint8Array;
+            toProtoMsg(message: _64.MessageOptions): _64.MessageOptionsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        FieldOptions: {
+            typeUrl: string;
+            is(o: any): o is _64.FieldOptions;
+            isAmino(o: any): o is _64.FieldOptionsAmino;
+            encode(message: _64.FieldOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.FieldOptions;
+            fromPartial(object: import("../helpers").DeepPartial<_64.FieldOptions>): _64.FieldOptions;
+            fromAmino(object: _64.FieldOptionsAmino): _64.FieldOptions;
+            toAmino(message: _64.FieldOptions): _64.FieldOptionsAmino;
+            fromAminoMsg(object: _64.FieldOptionsAminoMsg): _64.FieldOptions;
+            fromProtoMsg(message: _64.FieldOptionsProtoMsg): _64.FieldOptions;
+            toProto(message: _64.FieldOptions): Uint8Array;
+            toProtoMsg(message: _64.FieldOptions): _64.FieldOptionsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        FieldOptions_EditionDefault: {
+            typeUrl: string;
+            is(o: any): o is _64.FieldOptions_EditionDefault;
+            isAmino(o: any): o is _64.FieldOptions_EditionDefaultAmino;
+            encode(message: _64.FieldOptions_EditionDefault, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.FieldOptions_EditionDefault;
+            fromPartial(object: import("../helpers").DeepPartial<_64.FieldOptions_EditionDefault>): _64.FieldOptions_EditionDefault;
+            fromAmino(object: _64.FieldOptions_EditionDefaultAmino): _64.FieldOptions_EditionDefault;
+            toAmino(message: _64.FieldOptions_EditionDefault): _64.FieldOptions_EditionDefaultAmino;
+            fromAminoMsg(object: _64.FieldOptions_EditionDefaultAminoMsg): _64.FieldOptions_EditionDefault;
+            fromProtoMsg(message: _64.FieldOptions_EditionDefaultProtoMsg): _64.FieldOptions_EditionDefault;
+            toProto(message: _64.FieldOptions_EditionDefault): Uint8Array;
+            toProtoMsg(message: _64.FieldOptions_EditionDefault): _64.FieldOptions_EditionDefaultProtoMsg;
+            registerTypeUrl(): void;
+        };
+        FieldOptions_FeatureSupport: {
+            typeUrl: string;
+            is(o: any): o is _64.FieldOptions_FeatureSupport;
+            isAmino(o: any): o is _64.FieldOptions_FeatureSupportAmino;
+            encode(message: _64.FieldOptions_FeatureSupport, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.FieldOptions_FeatureSupport;
+            fromPartial(object: import("../helpers").DeepPartial<_64.FieldOptions_FeatureSupport>): _64.FieldOptions_FeatureSupport;
+            fromAmino(object: _64.FieldOptions_FeatureSupportAmino): _64.FieldOptions_FeatureSupport;
+            toAmino(message: _64.FieldOptions_FeatureSupport): _64.FieldOptions_FeatureSupportAmino;
+            fromAminoMsg(object: _64.FieldOptions_FeatureSupportAminoMsg): _64.FieldOptions_FeatureSupport;
+            fromProtoMsg(message: _64.FieldOptions_FeatureSupportProtoMsg): _64.FieldOptions_FeatureSupport;
+            toProto(message: _64.FieldOptions_FeatureSupport): Uint8Array;
+            toProtoMsg(message: _64.FieldOptions_FeatureSupport): _64.FieldOptions_FeatureSupportProtoMsg;
+            registerTypeUrl(): void;
+        };
+        OneofOptions: {
+            typeUrl: string;
+            is(o: any): o is _64.OneofOptions;
+            isAmino(o: any): o is _64.OneofOptionsAmino;
+            encode(message: _64.OneofOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.OneofOptions;
+            fromPartial(object: import("../helpers").DeepPartial<_64.OneofOptions>): _64.OneofOptions;
+            fromAmino(object: _64.OneofOptionsAmino): _64.OneofOptions;
+            toAmino(message: _64.OneofOptions): _64.OneofOptionsAmino;
+            fromAminoMsg(object: _64.OneofOptionsAminoMsg): _64.OneofOptions;
+            fromProtoMsg(message: _64.OneofOptionsProtoMsg): _64.OneofOptions;
+            toProto(message: _64.OneofOptions): Uint8Array;
+            toProtoMsg(message: _64.OneofOptions): _64.OneofOptionsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        EnumOptions: {
+            typeUrl: string;
+            is(o: any): o is _64.EnumOptions;
+            isAmino(o: any): o is _64.EnumOptionsAmino;
+            encode(message: _64.EnumOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.EnumOptions;
+            fromPartial(object: import("../helpers").DeepPartial<_64.EnumOptions>): _64.EnumOptions;
+            fromAmino(object: _64.EnumOptionsAmino): _64.EnumOptions;
+            toAmino(message: _64.EnumOptions): _64.EnumOptionsAmino;
+            fromAminoMsg(object: _64.EnumOptionsAminoMsg): _64.EnumOptions;
+            fromProtoMsg(message: _64.EnumOptionsProtoMsg): _64.EnumOptions;
+            toProto(message: _64.EnumOptions): Uint8Array;
+            toProtoMsg(message: _64.EnumOptions): _64.EnumOptionsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        EnumValueOptions: {
+            typeUrl: string;
+            is(o: any): o is _64.EnumValueOptions;
+            isAmino(o: any): o is _64.EnumValueOptionsAmino;
+            encode(message: _64.EnumValueOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.EnumValueOptions;
+            fromPartial(object: import("../helpers").DeepPartial<_64.EnumValueOptions>): _64.EnumValueOptions;
+            fromAmino(object: _64.EnumValueOptionsAmino): _64.EnumValueOptions;
+            toAmino(message: _64.EnumValueOptions): _64.EnumValueOptionsAmino;
+            fromAminoMsg(object: _64.EnumValueOptionsAminoMsg): _64.EnumValueOptions;
+            fromProtoMsg(message: _64.EnumValueOptionsProtoMsg): _64.EnumValueOptions;
+            toProto(message: _64.EnumValueOptions): Uint8Array;
+            toProtoMsg(message: _64.EnumValueOptions): _64.EnumValueOptionsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        ServiceOptions: {
+            typeUrl: string;
+            is(o: any): o is _64.ServiceOptions;
+            isAmino(o: any): o is _64.ServiceOptionsAmino;
+            encode(message: _64.ServiceOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.ServiceOptions;
+            fromPartial(object: import("../helpers").DeepPartial<_64.ServiceOptions>): _64.ServiceOptions;
+            fromAmino(object: _64.ServiceOptionsAmino): _64.ServiceOptions;
+            toAmino(message: _64.ServiceOptions): _64.ServiceOptionsAmino;
+            fromAminoMsg(object: _64.ServiceOptionsAminoMsg): _64.ServiceOptions;
+            fromProtoMsg(message: _64.ServiceOptionsProtoMsg): _64.ServiceOptions;
+            toProto(message: _64.ServiceOptions): Uint8Array;
+            toProtoMsg(message: _64.ServiceOptions): _64.ServiceOptionsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        MethodOptions: {
+            typeUrl: string;
+            is(o: any): o is _64.MethodOptions;
+            isAmino(o: any): o is _64.MethodOptionsAmino;
+            encode(message: _64.MethodOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.MethodOptions;
+            fromPartial(object: import("../helpers").DeepPartial<_64.MethodOptions>): _64.MethodOptions;
+            fromAmino(object: _64.MethodOptionsAmino): _64.MethodOptions;
+            toAmino(message: _64.MethodOptions): _64.MethodOptionsAmino;
+            fromAminoMsg(object: _64.MethodOptionsAminoMsg): _64.MethodOptions;
+            fromProtoMsg(message: _64.MethodOptionsProtoMsg): _64.MethodOptions;
+            toProto(message: _64.MethodOptions): Uint8Array;
+            toProtoMsg(message: _64.MethodOptions): _64.MethodOptionsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        UninterpretedOption: {
+            typeUrl: string;
+            is(o: any): o is _64.UninterpretedOption;
+            isAmino(o: any): o is _64.UninterpretedOptionAmino;
+            encode(message: _64.UninterpretedOption, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.UninterpretedOption;
+            fromPartial(object: import("../helpers").DeepPartial<_64.UninterpretedOption>): _64.UninterpretedOption;
+            fromAmino(object: _64.UninterpretedOptionAmino): _64.UninterpretedOption;
+            toAmino(message: _64.UninterpretedOption): _64.UninterpretedOptionAmino;
+            fromAminoMsg(object: _64.UninterpretedOptionAminoMsg): _64.UninterpretedOption;
+            fromProtoMsg(message: _64.UninterpretedOptionProtoMsg): _64.UninterpretedOption;
+            toProto(message: _64.UninterpretedOption): Uint8Array;
+            toProtoMsg(message: _64.UninterpretedOption): _64.UninterpretedOptionProtoMsg;
+            registerTypeUrl(): void;
+        };
+        UninterpretedOption_NamePart: {
+            typeUrl: string;
+            is(o: any): o is _64.UninterpretedOption_NamePart;
+            isAmino(o: any): o is _64.UninterpretedOption_NamePartAmino;
+            encode(message: _64.UninterpretedOption_NamePart, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.UninterpretedOption_NamePart;
+            fromPartial(object: import("../helpers").DeepPartial<_64.UninterpretedOption_NamePart>): _64.UninterpretedOption_NamePart;
+            fromAmino(object: _64.UninterpretedOption_NamePartAmino): _64.UninterpretedOption_NamePart;
+            toAmino(message: _64.UninterpretedOption_NamePart): _64.UninterpretedOption_NamePartAmino;
+            fromAminoMsg(object: _64.UninterpretedOption_NamePartAminoMsg): _64.UninterpretedOption_NamePart;
+            fromProtoMsg(message: _64.UninterpretedOption_NamePartProtoMsg): _64.UninterpretedOption_NamePart;
+            toProto(message: _64.UninterpretedOption_NamePart): Uint8Array;
+            toProtoMsg(message: _64.UninterpretedOption_NamePart): _64.UninterpretedOption_NamePartProtoMsg;
+            registerTypeUrl(): void;
+        };
+        FeatureSet: {
+            typeUrl: string;
+            is(o: any): o is _64.FeatureSet;
+            isAmino(o: any): o is _64.FeatureSetAmino;
+            encode(message: _64.FeatureSet, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.FeatureSet;
+            fromPartial(object: import("../helpers").DeepPartial<_64.FeatureSet>): _64.FeatureSet;
+            fromAmino(object: _64.FeatureSetAmino): _64.FeatureSet;
+            toAmino(message: _64.FeatureSet): _64.FeatureSetAmino;
+            fromAminoMsg(object: _64.FeatureSetAminoMsg): _64.FeatureSet;
+            fromProtoMsg(message: _64.FeatureSetProtoMsg): _64.FeatureSet;
+            toProto(message: _64.FeatureSet): Uint8Array;
+            toProtoMsg(message: _64.FeatureSet): _64.FeatureSetProtoMsg;
+            registerTypeUrl(): void;
+        };
+        FeatureSet_VisibilityFeature: {
+            typeUrl: string;
+            is(o: any): o is _64.FeatureSet_VisibilityFeature;
+            isAmino(o: any): o is _64.FeatureSet_VisibilityFeatureAmino;
+            encode(_: _64.FeatureSet_VisibilityFeature, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.FeatureSet_VisibilityFeature;
+            fromPartial(_: import("../helpers").DeepPartial<_64.FeatureSet_VisibilityFeature>): _64.FeatureSet_VisibilityFeature;
+            fromAmino(_: _64.FeatureSet_VisibilityFeatureAmino): _64.FeatureSet_VisibilityFeature;
+            toAmino(_: _64.FeatureSet_VisibilityFeature): _64.FeatureSet_VisibilityFeatureAmino;
+            fromAminoMsg(object: _64.FeatureSet_VisibilityFeatureAminoMsg): _64.FeatureSet_VisibilityFeature;
+            fromProtoMsg(message: _64.FeatureSet_VisibilityFeatureProtoMsg): _64.FeatureSet_VisibilityFeature;
+            toProto(message: _64.FeatureSet_VisibilityFeature): Uint8Array;
+            toProtoMsg(message: _64.FeatureSet_VisibilityFeature): _64.FeatureSet_VisibilityFeatureProtoMsg;
+            registerTypeUrl(): void;
+        };
+        FeatureSetDefaults: {
+            typeUrl: string;
+            is(o: any): o is _64.FeatureSetDefaults;
+            isAmino(o: any): o is _64.FeatureSetDefaultsAmino;
+            encode(message: _64.FeatureSetDefaults, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.FeatureSetDefaults;
+            fromPartial(object: import("../helpers").DeepPartial<_64.FeatureSetDefaults>): _64.FeatureSetDefaults;
+            fromAmino(object: _64.FeatureSetDefaultsAmino): _64.FeatureSetDefaults;
+            toAmino(message: _64.FeatureSetDefaults): _64.FeatureSetDefaultsAmino;
+            fromAminoMsg(object: _64.FeatureSetDefaultsAminoMsg): _64.FeatureSetDefaults;
+            fromProtoMsg(message: _64.FeatureSetDefaultsProtoMsg): _64.FeatureSetDefaults;
+            toProto(message: _64.FeatureSetDefaults): Uint8Array;
+            toProtoMsg(message: _64.FeatureSetDefaults): _64.FeatureSetDefaultsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        FeatureSetDefaults_FeatureSetEditionDefault: {
+            typeUrl: string;
+            is(o: any): o is _64.FeatureSetDefaults_FeatureSetEditionDefault;
+            isAmino(o: any): o is _64.FeatureSetDefaults_FeatureSetEditionDefaultAmino;
+            encode(message: _64.FeatureSetDefaults_FeatureSetEditionDefault, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.FeatureSetDefaults_FeatureSetEditionDefault;
+            fromPartial(object: import("../helpers").DeepPartial<_64.FeatureSetDefaults_FeatureSetEditionDefault>): _64.FeatureSetDefaults_FeatureSetEditionDefault;
+            fromAmino(object: _64.FeatureSetDefaults_FeatureSetEditionDefaultAmino): _64.FeatureSetDefaults_FeatureSetEditionDefault;
+            toAmino(message: _64.FeatureSetDefaults_FeatureSetEditionDefault): _64.FeatureSetDefaults_FeatureSetEditionDefaultAmino;
+            fromAminoMsg(object: _64.FeatureSetDefaults_FeatureSetEditionDefaultAminoMsg): _64.FeatureSetDefaults_FeatureSetEditionDefault;
+            fromProtoMsg(message: _64.FeatureSetDefaults_FeatureSetEditionDefaultProtoMsg): _64.FeatureSetDefaults_FeatureSetEditionDefault;
+            toProto(message: _64.FeatureSetDefaults_FeatureSetEditionDefault): Uint8Array;
+            toProtoMsg(message: _64.FeatureSetDefaults_FeatureSetEditionDefault): _64.FeatureSetDefaults_FeatureSetEditionDefaultProtoMsg;
+            registerTypeUrl(): void;
+        };
+        SourceCodeInfo: {
+            typeUrl: string;
+            is(o: any): o is _64.SourceCodeInfo;
+            isAmino(o: any): o is _64.SourceCodeInfoAmino;
+            encode(message: _64.SourceCodeInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.SourceCodeInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_64.SourceCodeInfo>): _64.SourceCodeInfo;
+            fromAmino(object: _64.SourceCodeInfoAmino): _64.SourceCodeInfo;
+            toAmino(message: _64.SourceCodeInfo): _64.SourceCodeInfoAmino;
+            fromAminoMsg(object: _64.SourceCodeInfoAminoMsg): _64.SourceCodeInfo;
+            fromProtoMsg(message: _64.SourceCodeInfoProtoMsg): _64.SourceCodeInfo;
+            toProto(message: _64.SourceCodeInfo): Uint8Array;
+            toProtoMsg(message: _64.SourceCodeInfo): _64.SourceCodeInfoProtoMsg;
+            registerTypeUrl(): void;
+        };
+        SourceCodeInfo_Location: {
+            typeUrl: string;
+            is(o: any): o is _64.SourceCodeInfo_Location;
+            isAmino(o: any): o is _64.SourceCodeInfo_LocationAmino;
+            encode(message: _64.SourceCodeInfo_Location, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.SourceCodeInfo_Location;
+            fromPartial(object: import("../helpers").DeepPartial<_64.SourceCodeInfo_Location>): _64.SourceCodeInfo_Location;
+            fromAmino(object: _64.SourceCodeInfo_LocationAmino): _64.SourceCodeInfo_Location;
+            toAmino(message: _64.SourceCodeInfo_Location): _64.SourceCodeInfo_LocationAmino;
+            fromAminoMsg(object: _64.SourceCodeInfo_LocationAminoMsg): _64.SourceCodeInfo_Location;
+            fromProtoMsg(message: _64.SourceCodeInfo_LocationProtoMsg): _64.SourceCodeInfo_Location;
+            toProto(message: _64.SourceCodeInfo_Location): Uint8Array;
+            toProtoMsg(message: _64.SourceCodeInfo_Location): _64.SourceCodeInfo_LocationProtoMsg;
+            registerTypeUrl(): void;
+        };
+        GeneratedCodeInfo: {
+            typeUrl: string;
+            is(o: any): o is _64.GeneratedCodeInfo;
+            isAmino(o: any): o is _64.GeneratedCodeInfoAmino;
+            encode(message: _64.GeneratedCodeInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.GeneratedCodeInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_64.GeneratedCodeInfo>): _64.GeneratedCodeInfo;
+            fromAmino(object: _64.GeneratedCodeInfoAmino): _64.GeneratedCodeInfo;
+            toAmino(message: _64.GeneratedCodeInfo): _64.GeneratedCodeInfoAmino;
+            fromAminoMsg(object: _64.GeneratedCodeInfoAminoMsg): _64.GeneratedCodeInfo;
+            fromProtoMsg(message: _64.GeneratedCodeInfoProtoMsg): _64.GeneratedCodeInfo;
+            toProto(message: _64.GeneratedCodeInfo): Uint8Array;
+            toProtoMsg(message: _64.GeneratedCodeInfo): _64.GeneratedCodeInfoProtoMsg;
+            registerTypeUrl(): void;
+        };
+        GeneratedCodeInfo_Annotation: {
+            typeUrl: string;
+            is(o: any): o is _64.GeneratedCodeInfo_Annotation;
+            isAmino(o: any): o is _64.GeneratedCodeInfo_AnnotationAmino;
+            encode(message: _64.GeneratedCodeInfo_Annotation, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _64.GeneratedCodeInfo_Annotation;
+            fromPartial(object: import("../helpers").DeepPartial<_64.GeneratedCodeInfo_Annotation>): _64.GeneratedCodeInfo_Annotation;
+            fromAmino(object: _64.GeneratedCodeInfo_AnnotationAmino): _64.GeneratedCodeInfo_Annotation;
+            toAmino(message: _64.GeneratedCodeInfo_Annotation): _64.GeneratedCodeInfo_AnnotationAmino;
+            fromAminoMsg(object: _64.GeneratedCodeInfo_AnnotationAminoMsg): _64.GeneratedCodeInfo_Annotation;
+            fromProtoMsg(message: _64.GeneratedCodeInfo_AnnotationProtoMsg): _64.GeneratedCodeInfo_Annotation;
+            toProto(message: _64.GeneratedCodeInfo_Annotation): Uint8Array;
+            toProtoMsg(message: _64.GeneratedCodeInfo_Annotation): _64.GeneratedCodeInfo_AnnotationProtoMsg;
+            registerTypeUrl(): void;
+        };
+        Duration: {
+            typeUrl: string;
+            is(o: any): o is _63.Duration;
+            isAmino(o: any): o is _63.DurationAmino;
+            encode(message: _63.Duration, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _63.Duration;
+            fromPartial(object: import("../helpers").DeepPartial<_63.Duration>): _63.Duration;
+            fromAmino(object: _63.DurationAmino): _63.Duration;
+            toAmino(message: _63.Duration): _63.DurationAmino;
+            fromAminoMsg(object: _63.DurationAminoMsg): _63.Duration;
+            fromProtoMsg(message: _63.DurationProtoMsg): _63.Duration;
+            toProto(message: _63.Duration): Uint8Array;
+            toProtoMsg(message: _63.Duration): _63.DurationProtoMsg;
+            registerTypeUrl(): void;
+        };
+        Timestamp: {
+            typeUrl: string;
+            is(o: any): o is _62.Timestamp;
+            isAmino(o: any): o is _62.TimestampAmino;
+            encode(message: _62.Timestamp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _62.Timestamp;
+            fromPartial(object: import("../helpers").DeepPartial<_62.Timestamp>): _62.Timestamp;
+            fromAmino(object: _62.TimestampAmino): _62.Timestamp;
+            toAmino(message: _62.Timestamp): _62.TimestampAmino;
+            fromAminoMsg(object: _62.TimestampAminoMsg): _62.Timestamp;
+            fromProtoMsg(message: _62.TimestampProtoMsg): _62.Timestamp;
+            toProto(message: _62.Timestamp): Uint8Array;
+            toProtoMsg(message: _62.Timestamp): _62.TimestampProtoMsg;
+            registerTypeUrl(): void;
+        };
+    };
+    const longrunning: {
+        Operation: {
+            typeUrl: string;
+            is(o: any): o is _70.Operation;
+            isAmino(o: any): o is _70.OperationAmino;
+            encode(message: _70.Operation, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _70.Operation;
+            fromPartial(object: import("../helpers").DeepPartial<_70.Operation>): _70.Operation;
+            fromAmino(object: _70.OperationAmino): _70.Operation;
+            toAmino(message: _70.Operation): _70.OperationAmino;
+            fromAminoMsg(object: _70.OperationAminoMsg): _70.Operation;
+            fromProtoMsg(message: _70.OperationProtoMsg): _70.Operation;
+            toProto(message: _70.Operation): Uint8Array;
+            toProtoMsg(message: _70.Operation): _70.OperationProtoMsg;
+            registerTypeUrl(): void;
+        };
+        GetOperationRequest: {
+            typeUrl: string;
+            is(o: any): o is _70.GetOperationRequest;
+            isAmino(o: any): o is _70.GetOperationRequestAmino;
+            encode(message: _70.GetOperationRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _70.GetOperationRequest;
+            fromPartial(object: import("../helpers").DeepPartial<_70.GetOperationRequest>): _70.GetOperationRequest;
+            fromAmino(object: _70.GetOperationRequestAmino): _70.GetOperationRequest;
+            toAmino(message: _70.GetOperationRequest): _70.GetOperationRequestAmino;
+            fromAminoMsg(object: _70.GetOperationRequestAminoMsg): _70.GetOperationRequest;
+            fromProtoMsg(message: _70.GetOperationRequestProtoMsg): _70.GetOperationRequest;
+            toProto(message: _70.GetOperationRequest): Uint8Array;
+            toProtoMsg(message: _70.GetOperationRequest): _70.GetOperationRequestProtoMsg;
+            registerTypeUrl(): void;
+        };
+        ListOperationsRequest: {
+            typeUrl: string;
+            is(o: any): o is _70.ListOperationsRequest;
+            isAmino(o: any): o is _70.ListOperationsRequestAmino;
+            encode(message: _70.ListOperationsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _70.ListOperationsRequest;
+            fromPartial(object: import("../helpers").DeepPartial<_70.ListOperationsRequest>): _70.ListOperationsRequest;
+            fromAmino(object: _70.ListOperationsRequestAmino): _70.ListOperationsRequest;
+            toAmino(message: _70.ListOperationsRequest): _70.ListOperationsRequestAmino;
+            fromAminoMsg(object: _70.ListOperationsRequestAminoMsg): _70.ListOperationsRequest;
+            fromProtoMsg(message: _70.ListOperationsRequestProtoMsg): _70.ListOperationsRequest;
+            toProto(message: _70.ListOperationsRequest): Uint8Array;
+            toProtoMsg(message: _70.ListOperationsRequest): _70.ListOperationsRequestProtoMsg;
+            registerTypeUrl(): void;
+        };
+        ListOperationsResponse: {
+            typeUrl: string;
+            is(o: any): o is _70.ListOperationsResponse;
+            isAmino(o: any): o is _70.ListOperationsResponseAmino;
+            encode(message: _70.ListOperationsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _70.ListOperationsResponse;
+            fromPartial(object: import("../helpers").DeepPartial<_70.ListOperationsResponse>): _70.ListOperationsResponse;
+            fromAmino(object: _70.ListOperationsResponseAmino): _70.ListOperationsResponse;
+            toAmino(message: _70.ListOperationsResponse): _70.ListOperationsResponseAmino;
+            fromAminoMsg(object: _70.ListOperationsResponseAminoMsg): _70.ListOperationsResponse;
+            fromProtoMsg(message: _70.ListOperationsResponseProtoMsg): _70.ListOperationsResponse;
+            toProto(message: _70.ListOperationsResponse): Uint8Array;
+            toProtoMsg(message: _70.ListOperationsResponse): _70.ListOperationsResponseProtoMsg;
+            registerTypeUrl(): void;
+        };
+        CancelOperationRequest: {
+            typeUrl: string;
+            is(o: any): o is _70.CancelOperationRequest;
+            isAmino(o: any): o is _70.CancelOperationRequestAmino;
+            encode(message: _70.CancelOperationRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _70.CancelOperationRequest;
+            fromPartial(object: import("../helpers").DeepPartial<_70.CancelOperationRequest>): _70.CancelOperationRequest;
+            fromAmino(object: _70.CancelOperationRequestAmino): _70.CancelOperationRequest;
+            toAmino(message: _70.CancelOperationRequest): _70.CancelOperationRequestAmino;
+            fromAminoMsg(object: _70.CancelOperationRequestAminoMsg): _70.CancelOperationRequest;
+            fromProtoMsg(message: _70.CancelOperationRequestProtoMsg): _70.CancelOperationRequest;
+            toProto(message: _70.CancelOperationRequest): Uint8Array;
+            toProtoMsg(message: _70.CancelOperationRequest): _70.CancelOperationRequestProtoMsg;
+            registerTypeUrl(): void;
+        };
+        DeleteOperationRequest: {
+            typeUrl: string;
+            is(o: any): o is _70.DeleteOperationRequest;
+            isAmino(o: any): o is _70.DeleteOperationRequestAmino;
+            encode(message: _70.DeleteOperationRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _70.DeleteOperationRequest;
+            fromPartial(object: import("../helpers").DeepPartial<_70.DeleteOperationRequest>): _70.DeleteOperationRequest;
+            fromAmino(object: _70.DeleteOperationRequestAmino): _70.DeleteOperationRequest;
+            toAmino(message: _70.DeleteOperationRequest): _70.DeleteOperationRequestAmino;
+            fromAminoMsg(object: _70.DeleteOperationRequestAminoMsg): _70.DeleteOperationRequest;
+            fromProtoMsg(message: _70.DeleteOperationRequestProtoMsg): _70.DeleteOperationRequest;
+            toProto(message: _70.DeleteOperationRequest): Uint8Array;
+            toProtoMsg(message: _70.DeleteOperationRequest): _70.DeleteOperationRequestProtoMsg;
+            registerTypeUrl(): void;
+        };
+        WaitOperationRequest: {
+            typeUrl: string;
+            is(o: any): o is _70.WaitOperationRequest;
+            isAmino(o: any): o is _70.WaitOperationRequestAmino;
+            encode(message: _70.WaitOperationRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _70.WaitOperationRequest;
+            fromPartial(object: import("../helpers").DeepPartial<_70.WaitOperationRequest>): _70.WaitOperationRequest;
+            fromAmino(object: _70.WaitOperationRequestAmino): _70.WaitOperationRequest;
+            toAmino(message: _70.WaitOperationRequest): _70.WaitOperationRequestAmino;
+            fromAminoMsg(object: _70.WaitOperationRequestAminoMsg): _70.WaitOperationRequest;
+            fromProtoMsg(message: _70.WaitOperationRequestProtoMsg): _70.WaitOperationRequest;
+            toProto(message: _70.WaitOperationRequest): Uint8Array;
+            toProtoMsg(message: _70.WaitOperationRequest): _70.WaitOperationRequestProtoMsg;
+            registerTypeUrl(): void;
+        };
+        OperationInfo: {
+            typeUrl: string;
+            is(o: any): o is _70.OperationInfo;
+            isAmino(o: any): o is _70.OperationInfoAmino;
+            encode(message: _70.OperationInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _70.OperationInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_70.OperationInfo>): _70.OperationInfo;
+            fromAmino(object: _70.OperationInfoAmino): _70.OperationInfo;
+            toAmino(message: _70.OperationInfo): _70.OperationInfoAmino;
+            fromAminoMsg(object: _70.OperationInfoAminoMsg): _70.OperationInfo;
+            fromProtoMsg(message: _70.OperationInfoProtoMsg): _70.OperationInfo;
+            toProto(message: _70.OperationInfo): Uint8Array;
+            toProtoMsg(message: _70.OperationInfo): _70.OperationInfoProtoMsg;
+            registerTypeUrl(): void;
+        };
+    };
+    namespace iam {
+        const v1: {
+            SetIamPolicyRequest: {
+                typeUrl: string;
+                is(o: any): o is _73.SetIamPolicyRequest;
+                isAmino(o: any): o is _73.SetIamPolicyRequestAmino;
+                encode(message: _73.SetIamPolicyRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _73.SetIamPolicyRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_73.SetIamPolicyRequest>): _73.SetIamPolicyRequest;
+                fromAmino(object: _73.SetIamPolicyRequestAmino): _73.SetIamPolicyRequest;
+                toAmino(message: _73.SetIamPolicyRequest): _73.SetIamPolicyRequestAmino;
+                fromAminoMsg(object: _73.SetIamPolicyRequestAminoMsg): _73.SetIamPolicyRequest;
+                fromProtoMsg(message: _73.SetIamPolicyRequestProtoMsg): _73.SetIamPolicyRequest;
+                toProto(message: _73.SetIamPolicyRequest): Uint8Array;
+                toProtoMsg(message: _73.SetIamPolicyRequest): _73.SetIamPolicyRequestProtoMsg;
+                registerTypeUrl(): void;
+            };
+            GetIamPolicyRequest: {
+                typeUrl: string;
+                is(o: any): o is _73.GetIamPolicyRequest;
+                isAmino(o: any): o is _73.GetIamPolicyRequestAmino;
+                encode(message: _73.GetIamPolicyRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _73.GetIamPolicyRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_73.GetIamPolicyRequest>): _73.GetIamPolicyRequest;
+                fromAmino(object: _73.GetIamPolicyRequestAmino): _73.GetIamPolicyRequest;
+                toAmino(message: _73.GetIamPolicyRequest): _73.GetIamPolicyRequestAmino;
+                fromAminoMsg(object: _73.GetIamPolicyRequestAminoMsg): _73.GetIamPolicyRequest;
+                fromProtoMsg(message: _73.GetIamPolicyRequestProtoMsg): _73.GetIamPolicyRequest;
+                toProto(message: _73.GetIamPolicyRequest): Uint8Array;
+                toProtoMsg(message: _73.GetIamPolicyRequest): _73.GetIamPolicyRequestProtoMsg;
+                registerTypeUrl(): void;
+            };
+            TestIamPermissionsRequest: {
+                typeUrl: string;
+                is(o: any): o is _73.TestIamPermissionsRequest;
+                isAmino(o: any): o is _73.TestIamPermissionsRequestAmino;
+                encode(message: _73.TestIamPermissionsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _73.TestIamPermissionsRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_73.TestIamPermissionsRequest>): _73.TestIamPermissionsRequest;
+                fromAmino(object: _73.TestIamPermissionsRequestAmino): _73.TestIamPermissionsRequest;
+                toAmino(message: _73.TestIamPermissionsRequest): _73.TestIamPermissionsRequestAmino;
+                fromAminoMsg(object: _73.TestIamPermissionsRequestAminoMsg): _73.TestIamPermissionsRequest;
+                fromProtoMsg(message: _73.TestIamPermissionsRequestProtoMsg): _73.TestIamPermissionsRequest;
+                toProto(message: _73.TestIamPermissionsRequest): Uint8Array;
+                toProtoMsg(message: _73.TestIamPermissionsRequest): _73.TestIamPermissionsRequestProtoMsg;
+                registerTypeUrl(): void;
+            };
+            TestIamPermissionsResponse: {
+                typeUrl: string;
+                is(o: any): o is _73.TestIamPermissionsResponse;
+                isAmino(o: any): o is _73.TestIamPermissionsResponseAmino;
+                encode(message: _73.TestIamPermissionsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _73.TestIamPermissionsResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_73.TestIamPermissionsResponse>): _73.TestIamPermissionsResponse;
+                fromAmino(object: _73.TestIamPermissionsResponseAmino): _73.TestIamPermissionsResponse;
+                toAmino(message: _73.TestIamPermissionsResponse): _73.TestIamPermissionsResponseAmino;
+                fromAminoMsg(object: _73.TestIamPermissionsResponseAminoMsg): _73.TestIamPermissionsResponse;
+                fromProtoMsg(message: _73.TestIamPermissionsResponseProtoMsg): _73.TestIamPermissionsResponse;
+                toProto(message: _73.TestIamPermissionsResponse): Uint8Array;
+                toProtoMsg(message: _73.TestIamPermissionsResponse): _73.TestIamPermissionsResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            GetPolicyOptions: {
+                typeUrl: string;
+                is(o: any): o is _72.GetPolicyOptions;
+                isAmino(o: any): o is _72.GetPolicyOptionsAmino;
+                encode(message: _72.GetPolicyOptions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _72.GetPolicyOptions;
+                fromPartial(object: import("../helpers").DeepPartial<_72.GetPolicyOptions>): _72.GetPolicyOptions;
+                fromAmino(object: _72.GetPolicyOptionsAmino): _72.GetPolicyOptions;
+                toAmino(message: _72.GetPolicyOptions): _72.GetPolicyOptionsAmino;
+                fromAminoMsg(object: _72.GetPolicyOptionsAminoMsg): _72.GetPolicyOptions;
+                fromProtoMsg(message: _72.GetPolicyOptionsProtoMsg): _72.GetPolicyOptions;
+                toProto(message: _72.GetPolicyOptions): Uint8Array;
+                toProtoMsg(message: _72.GetPolicyOptions): _72.GetPolicyOptionsProtoMsg;
+                registerTypeUrl(): void;
+            };
+            auditLogConfig_LogTypeFromJSON(object: any): _71.AuditLogConfig_LogType;
+            auditLogConfig_LogTypeToJSON(object: _71.AuditLogConfig_LogType): string;
+            bindingDelta_ActionFromJSON(object: any): _71.BindingDelta_Action;
+            bindingDelta_ActionToJSON(object: _71.BindingDelta_Action): string;
+            auditConfigDelta_ActionFromJSON(object: any): _71.AuditConfigDelta_Action;
+            auditConfigDelta_ActionToJSON(object: _71.AuditConfigDelta_Action): string;
+            AuditLogConfig_LogType: typeof _71.AuditLogConfig_LogType;
+            AuditLogConfig_LogTypeAmino: typeof _71.AuditLogConfig_LogType;
+            BindingDelta_Action: typeof _71.BindingDelta_Action;
+            BindingDelta_ActionAmino: typeof _71.BindingDelta_Action;
+            AuditConfigDelta_Action: typeof _71.AuditConfigDelta_Action;
+            AuditConfigDelta_ActionAmino: typeof _71.AuditConfigDelta_Action;
+            Policy: {
+                typeUrl: string;
+                is(o: any): o is _71.Policy;
+                isAmino(o: any): o is _71.PolicyAmino;
+                encode(message: _71.Policy, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _71.Policy;
+                fromPartial(object: import("../helpers").DeepPartial<_71.Policy>): _71.Policy;
+                fromAmino(object: _71.PolicyAmino): _71.Policy;
+                toAmino(message: _71.Policy): _71.PolicyAmino;
+                fromAminoMsg(object: _71.PolicyAminoMsg): _71.Policy;
+                fromProtoMsg(message: _71.PolicyProtoMsg): _71.Policy;
+                toProto(message: _71.Policy): Uint8Array;
+                toProtoMsg(message: _71.Policy): _71.PolicyProtoMsg;
+                registerTypeUrl(): void;
+            };
+            Binding: {
+                typeUrl: string;
+                is(o: any): o is _71.Binding;
+                isAmino(o: any): o is _71.BindingAmino;
+                encode(message: _71.Binding, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _71.Binding;
+                fromPartial(object: import("../helpers").DeepPartial<_71.Binding>): _71.Binding;
+                fromAmino(object: _71.BindingAmino): _71.Binding;
+                toAmino(message: _71.Binding): _71.BindingAmino;
+                fromAminoMsg(object: _71.BindingAminoMsg): _71.Binding;
+                fromProtoMsg(message: _71.BindingProtoMsg): _71.Binding;
+                toProto(message: _71.Binding): Uint8Array;
+                toProtoMsg(message: _71.Binding): _71.BindingProtoMsg;
+                registerTypeUrl(): void;
+            };
+            AuditConfig: {
+                typeUrl: string;
+                is(o: any): o is _71.AuditConfig;
+                isAmino(o: any): o is _71.AuditConfigAmino;
+                encode(message: _71.AuditConfig, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _71.AuditConfig;
+                fromPartial(object: import("../helpers").DeepPartial<_71.AuditConfig>): _71.AuditConfig;
+                fromAmino(object: _71.AuditConfigAmino): _71.AuditConfig;
+                toAmino(message: _71.AuditConfig): _71.AuditConfigAmino;
+                fromAminoMsg(object: _71.AuditConfigAminoMsg): _71.AuditConfig;
+                fromProtoMsg(message: _71.AuditConfigProtoMsg): _71.AuditConfig;
+                toProto(message: _71.AuditConfig): Uint8Array;
+                toProtoMsg(message: _71.AuditConfig): _71.AuditConfigProtoMsg;
+                registerTypeUrl(): void;
+            };
+            AuditLogConfig: {
+                typeUrl: string;
+                is(o: any): o is _71.AuditLogConfig;
+                isAmino(o: any): o is _71.AuditLogConfigAmino;
+                encode(message: _71.AuditLogConfig, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _71.AuditLogConfig;
+                fromPartial(object: import("../helpers").DeepPartial<_71.AuditLogConfig>): _71.AuditLogConfig;
+                fromAmino(object: _71.AuditLogConfigAmino): _71.AuditLogConfig;
+                toAmino(message: _71.AuditLogConfig): _71.AuditLogConfigAmino;
+                fromAminoMsg(object: _71.AuditLogConfigAminoMsg): _71.AuditLogConfig;
+                fromProtoMsg(message: _71.AuditLogConfigProtoMsg): _71.AuditLogConfig;
+                toProto(message: _71.AuditLogConfig): Uint8Array;
+                toProtoMsg(message: _71.AuditLogConfig): _71.AuditLogConfigProtoMsg;
+                registerTypeUrl(): void;
+            };
+            PolicyDelta: {
+                typeUrl: string;
+                is(o: any): o is _71.PolicyDelta;
+                isAmino(o: any): o is _71.PolicyDeltaAmino;
+                encode(message: _71.PolicyDelta, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _71.PolicyDelta;
+                fromPartial(object: import("../helpers").DeepPartial<_71.PolicyDelta>): _71.PolicyDelta;
+                fromAmino(object: _71.PolicyDeltaAmino): _71.PolicyDelta;
+                toAmino(message: _71.PolicyDelta): _71.PolicyDeltaAmino;
+                fromAminoMsg(object: _71.PolicyDeltaAminoMsg): _71.PolicyDelta;
+                fromProtoMsg(message: _71.PolicyDeltaProtoMsg): _71.PolicyDelta;
+                toProto(message: _71.PolicyDelta): Uint8Array;
+                toProtoMsg(message: _71.PolicyDelta): _71.PolicyDeltaProtoMsg;
+                registerTypeUrl(): void;
+            };
+            BindingDelta: {
+                typeUrl: string;
+                is(o: any): o is _71.BindingDelta;
+                isAmino(o: any): o is _71.BindingDeltaAmino;
+                encode(message: _71.BindingDelta, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _71.BindingDelta;
+                fromPartial(object: import("../helpers").DeepPartial<_71.BindingDelta>): _71.BindingDelta;
+                fromAmino(object: _71.BindingDeltaAmino): _71.BindingDelta;
+                toAmino(message: _71.BindingDelta): _71.BindingDeltaAmino;
+                fromAminoMsg(object: _71.BindingDeltaAminoMsg): _71.BindingDelta;
+                fromProtoMsg(message: _71.BindingDeltaProtoMsg): _71.BindingDelta;
+                toProto(message: _71.BindingDelta): Uint8Array;
+                toProtoMsg(message: _71.BindingDelta): _71.BindingDeltaProtoMsg;
+                registerTypeUrl(): void;
+            };
+            AuditConfigDelta: {
+                typeUrl: string;
+                is(o: any): o is _71.AuditConfigDelta;
+                isAmino(o: any): o is _71.AuditConfigDeltaAmino;
+                encode(message: _71.AuditConfigDelta, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _71.AuditConfigDelta;
+                fromPartial(object: import("../helpers").DeepPartial<_71.AuditConfigDelta>): _71.AuditConfigDelta;
+                fromAmino(object: _71.AuditConfigDeltaAmino): _71.AuditConfigDelta;
+                toAmino(message: _71.AuditConfigDelta): _71.AuditConfigDeltaAmino;
+                fromAminoMsg(object: _71.AuditConfigDeltaAminoMsg): _71.AuditConfigDelta;
+                fromProtoMsg(message: _71.AuditConfigDeltaProtoMsg): _71.AuditConfigDelta;
+                toProto(message: _71.AuditConfigDelta): Uint8Array;
+                toProtoMsg(message: _71.AuditConfigDelta): _71.AuditConfigDeltaProtoMsg;
+                registerTypeUrl(): void;
+            };
+        };
+    }
+    namespace geo {
+        const type: {
+            Viewport: {
+                typeUrl: string;
+                is(o: any): o is _74.Viewport;
+                isAmino(o: any): o is _74.ViewportAmino;
+                encode(message: _74.Viewport, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _74.Viewport;
+                fromPartial(object: import("../helpers").DeepPartial<_74.Viewport>): _74.Viewport;
+                fromAmino(object: _74.ViewportAmino): _74.Viewport;
+                toAmino(message: _74.Viewport): _74.ViewportAmino;
+                fromAminoMsg(object: _74.ViewportAminoMsg): _74.Viewport;
+                fromProtoMsg(message: _74.ViewportProtoMsg): _74.Viewport;
+                toProto(message: _74.Viewport): Uint8Array;
+                toProtoMsg(message: _74.Viewport): _74.ViewportProtoMsg;
+                registerTypeUrl(): void;
+            };
+        };
+    }
+    const bytestream: {
+        ReadRequest: {
+            typeUrl: string;
+            is(o: any): o is _75.ReadRequest;
+            isAmino(o: any): o is _75.ReadRequestAmino;
+            encode(message: _75.ReadRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _75.ReadRequest;
+            fromPartial(object: import("../helpers").DeepPartial<_75.ReadRequest>): _75.ReadRequest;
+            fromAmino(object: _75.ReadRequestAmino): _75.ReadRequest;
+            toAmino(message: _75.ReadRequest): _75.ReadRequestAmino;
+            fromAminoMsg(object: _75.ReadRequestAminoMsg): _75.ReadRequest;
+            fromProtoMsg(message: _75.ReadRequestProtoMsg): _75.ReadRequest;
+            toProto(message: _75.ReadRequest): Uint8Array;
+            toProtoMsg(message: _75.ReadRequest): _75.ReadRequestProtoMsg;
+            registerTypeUrl(): void;
+        };
+        ReadResponse: {
+            typeUrl: string;
+            is(o: any): o is _75.ReadResponse;
+            isAmino(o: any): o is _75.ReadResponseAmino;
+            encode(message: _75.ReadResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _75.ReadResponse;
+            fromPartial(object: import("../helpers").DeepPartial<_75.ReadResponse>): _75.ReadResponse;
+            fromAmino(object: _75.ReadResponseAmino): _75.ReadResponse;
+            toAmino(message: _75.ReadResponse): _75.ReadResponseAmino;
+            fromAminoMsg(object: _75.ReadResponseAminoMsg): _75.ReadResponse;
+            fromProtoMsg(message: _75.ReadResponseProtoMsg): _75.ReadResponse;
+            toProto(message: _75.ReadResponse): Uint8Array;
+            toProtoMsg(message: _75.ReadResponse): _75.ReadResponseProtoMsg;
+            registerTypeUrl(): void;
+        };
+        WriteRequest: {
+            typeUrl: string;
+            is(o: any): o is _75.WriteRequest;
+            isAmino(o: any): o is _75.WriteRequestAmino;
+            encode(message: _75.WriteRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _75.WriteRequest;
+            fromPartial(object: import("../helpers").DeepPartial<_75.WriteRequest>): _75.WriteRequest;
+            fromAmino(object: _75.WriteRequestAmino): _75.WriteRequest;
+            toAmino(message: _75.WriteRequest): _75.WriteRequestAmino;
+            fromAminoMsg(object: _75.WriteRequestAminoMsg): _75.WriteRequest;
+            fromProtoMsg(message: _75.WriteRequestProtoMsg): _75.WriteRequest;
+            toProto(message: _75.WriteRequest): Uint8Array;
+            toProtoMsg(message: _75.WriteRequest): _75.WriteRequestProtoMsg;
+            registerTypeUrl(): void;
+        };
+        WriteResponse: {
+            typeUrl: string;
+            is(o: any): o is _75.WriteResponse;
+            isAmino(o: any): o is _75.WriteResponseAmino;
+            encode(message: _75.WriteResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _75.WriteResponse;
+            fromPartial(object: import("../helpers").DeepPartial<_75.WriteResponse>): _75.WriteResponse;
+            fromAmino(object: _75.WriteResponseAmino): _75.WriteResponse;
+            toAmino(message: _75.WriteResponse): _75.WriteResponseAmino;
+            fromAminoMsg(object: _75.WriteResponseAminoMsg): _75.WriteResponse;
+            fromProtoMsg(message: _75.WriteResponseProtoMsg): _75.WriteResponse;
+            toProto(message: _75.WriteResponse): Uint8Array;
+            toProtoMsg(message: _75.WriteResponse): _75.WriteResponseProtoMsg;
+            registerTypeUrl(): void;
+        };
+        QueryWriteStatusRequest: {
+            typeUrl: string;
+            is(o: any): o is _75.QueryWriteStatusRequest;
+            isAmino(o: any): o is _75.QueryWriteStatusRequestAmino;
+            encode(message: _75.QueryWriteStatusRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _75.QueryWriteStatusRequest;
+            fromPartial(object: import("../helpers").DeepPartial<_75.QueryWriteStatusRequest>): _75.QueryWriteStatusRequest;
+            fromAmino(object: _75.QueryWriteStatusRequestAmino): _75.QueryWriteStatusRequest;
+            toAmino(message: _75.QueryWriteStatusRequest): _75.QueryWriteStatusRequestAmino;
+            fromAminoMsg(object: _75.QueryWriteStatusRequestAminoMsg): _75.QueryWriteStatusRequest;
+            fromProtoMsg(message: _75.QueryWriteStatusRequestProtoMsg): _75.QueryWriteStatusRequest;
+            toProto(message: _75.QueryWriteStatusRequest): Uint8Array;
+            toProtoMsg(message: _75.QueryWriteStatusRequest): _75.QueryWriteStatusRequestProtoMsg;
+            registerTypeUrl(): void;
+        };
+        QueryWriteStatusResponse: {
+            typeUrl: string;
+            is(o: any): o is _75.QueryWriteStatusResponse;
+            isAmino(o: any): o is _75.QueryWriteStatusResponseAmino;
+            encode(message: _75.QueryWriteStatusResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _75.QueryWriteStatusResponse;
+            fromPartial(object: import("../helpers").DeepPartial<_75.QueryWriteStatusResponse>): _75.QueryWriteStatusResponse;
+            fromAmino(object: _75.QueryWriteStatusResponseAmino): _75.QueryWriteStatusResponse;
+            toAmino(message: _75.QueryWriteStatusResponse): _75.QueryWriteStatusResponseAmino;
+            fromAminoMsg(object: _75.QueryWriteStatusResponseAminoMsg): _75.QueryWriteStatusResponse;
+            fromProtoMsg(message: _75.QueryWriteStatusResponseProtoMsg): _75.QueryWriteStatusResponse;
+            toProto(message: _75.QueryWriteStatusResponse): Uint8Array;
+            toProtoMsg(message: _75.QueryWriteStatusResponse): _75.QueryWriteStatusResponseProtoMsg;
+            registerTypeUrl(): void;
+        };
+    };
+    const api: {
+        clientLibraryOrganizationFromJSON(object: any): _84.ClientLibraryOrganization;
+        clientLibraryOrganizationToJSON(object: _84.ClientLibraryOrganization): string;
+        clientLibraryDestinationFromJSON(object: any): _84.ClientLibraryDestination;
+        clientLibraryDestinationToJSON(object: _84.ClientLibraryDestination): string;
+        ClientLibraryOrganization: typeof _84.ClientLibraryOrganization;
+        ClientLibraryOrganizationAmino: typeof _84.ClientLibraryOrganization;
+        ClientLibraryDestination: typeof _84.ClientLibraryDestination;
+        ClientLibraryDestinationAmino: typeof _84.ClientLibraryDestination;
+        CommonLanguageSettings: {
+            typeUrl: string;
+            is(o: any): o is _84.CommonLanguageSettings;
+            isAmino(o: any): o is _84.CommonLanguageSettingsAmino;
+            encode(message: _84.CommonLanguageSettings, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.CommonLanguageSettings;
+            fromPartial(object: import("../helpers").DeepPartial<_84.CommonLanguageSettings>): _84.CommonLanguageSettings;
+            fromAmino(object: _84.CommonLanguageSettingsAmino): _84.CommonLanguageSettings;
+            toAmino(message: _84.CommonLanguageSettings): _84.CommonLanguageSettingsAmino;
+            fromAminoMsg(object: _84.CommonLanguageSettingsAminoMsg): _84.CommonLanguageSettings;
+            fromProtoMsg(message: _84.CommonLanguageSettingsProtoMsg): _84.CommonLanguageSettings;
+            toProto(message: _84.CommonLanguageSettings): Uint8Array;
+            toProtoMsg(message: _84.CommonLanguageSettings): _84.CommonLanguageSettingsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        ClientLibrarySettings: {
+            typeUrl: string;
+            is(o: any): o is _84.ClientLibrarySettings;
+            isAmino(o: any): o is _84.ClientLibrarySettingsAmino;
+            encode(message: _84.ClientLibrarySettings, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.ClientLibrarySettings;
+            fromPartial(object: import("../helpers").DeepPartial<_84.ClientLibrarySettings>): _84.ClientLibrarySettings;
+            fromAmino(object: _84.ClientLibrarySettingsAmino): _84.ClientLibrarySettings;
+            toAmino(message: _84.ClientLibrarySettings): _84.ClientLibrarySettingsAmino;
+            fromAminoMsg(object: _84.ClientLibrarySettingsAminoMsg): _84.ClientLibrarySettings;
+            fromProtoMsg(message: _84.ClientLibrarySettingsProtoMsg): _84.ClientLibrarySettings;
+            toProto(message: _84.ClientLibrarySettings): Uint8Array;
+            toProtoMsg(message: _84.ClientLibrarySettings): _84.ClientLibrarySettingsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        Publishing: {
+            typeUrl: string;
+            is(o: any): o is _84.Publishing;
+            isAmino(o: any): o is _84.PublishingAmino;
+            encode(message: _84.Publishing, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.Publishing;
+            fromPartial(object: import("../helpers").DeepPartial<_84.Publishing>): _84.Publishing;
+            fromAmino(object: _84.PublishingAmino): _84.Publishing;
+            toAmino(message: _84.Publishing): _84.PublishingAmino;
+            fromAminoMsg(object: _84.PublishingAminoMsg): _84.Publishing;
+            fromProtoMsg(message: _84.PublishingProtoMsg): _84.Publishing;
+            toProto(message: _84.Publishing): Uint8Array;
+            toProtoMsg(message: _84.Publishing): _84.PublishingProtoMsg;
+            registerTypeUrl(): void;
+        };
+        JavaSettings_ServiceClassNamesEntry: {
+            encode(message: _84.JavaSettings_ServiceClassNamesEntry, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.JavaSettings_ServiceClassNamesEntry;
+            fromPartial(object: import("../helpers").DeepPartial<_84.JavaSettings_ServiceClassNamesEntry>): _84.JavaSettings_ServiceClassNamesEntry;
+            fromAmino(object: _84.JavaSettings_ServiceClassNamesEntryAmino): _84.JavaSettings_ServiceClassNamesEntry;
+            toAmino(message: _84.JavaSettings_ServiceClassNamesEntry): _84.JavaSettings_ServiceClassNamesEntryAmino;
+            fromAminoMsg(object: _84.JavaSettings_ServiceClassNamesEntryAminoMsg): _84.JavaSettings_ServiceClassNamesEntry;
+            fromProtoMsg(message: _84.JavaSettings_ServiceClassNamesEntryProtoMsg): _84.JavaSettings_ServiceClassNamesEntry;
+            toProto(message: _84.JavaSettings_ServiceClassNamesEntry): Uint8Array;
+            registerTypeUrl(): void;
+        };
+        JavaSettings: {
+            typeUrl: string;
+            is(o: any): o is _84.JavaSettings;
+            isAmino(o: any): o is _84.JavaSettingsAmino;
+            encode(message: _84.JavaSettings, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.JavaSettings;
+            fromPartial(object: import("../helpers").DeepPartial<_84.JavaSettings>): _84.JavaSettings;
+            fromAmino(object: _84.JavaSettingsAmino): _84.JavaSettings;
+            toAmino(message: _84.JavaSettings): _84.JavaSettingsAmino;
+            fromAminoMsg(object: _84.JavaSettingsAminoMsg): _84.JavaSettings;
+            fromProtoMsg(message: _84.JavaSettingsProtoMsg): _84.JavaSettings;
+            toProto(message: _84.JavaSettings): Uint8Array;
+            toProtoMsg(message: _84.JavaSettings): _84.JavaSettingsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        CppSettings: {
+            typeUrl: string;
+            is(o: any): o is _84.CppSettings;
+            isAmino(o: any): o is _84.CppSettingsAmino;
+            encode(message: _84.CppSettings, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.CppSettings;
+            fromPartial(object: import("../helpers").DeepPartial<_84.CppSettings>): _84.CppSettings;
+            fromAmino(object: _84.CppSettingsAmino): _84.CppSettings;
+            toAmino(message: _84.CppSettings): _84.CppSettingsAmino;
+            fromAminoMsg(object: _84.CppSettingsAminoMsg): _84.CppSettings;
+            fromProtoMsg(message: _84.CppSettingsProtoMsg): _84.CppSettings;
+            toProto(message: _84.CppSettings): Uint8Array;
+            toProtoMsg(message: _84.CppSettings): _84.CppSettingsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        PhpSettings: {
+            typeUrl: string;
+            is(o: any): o is _84.PhpSettings;
+            isAmino(o: any): o is _84.PhpSettingsAmino;
+            encode(message: _84.PhpSettings, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.PhpSettings;
+            fromPartial(object: import("../helpers").DeepPartial<_84.PhpSettings>): _84.PhpSettings;
+            fromAmino(object: _84.PhpSettingsAmino): _84.PhpSettings;
+            toAmino(message: _84.PhpSettings): _84.PhpSettingsAmino;
+            fromAminoMsg(object: _84.PhpSettingsAminoMsg): _84.PhpSettings;
+            fromProtoMsg(message: _84.PhpSettingsProtoMsg): _84.PhpSettings;
+            toProto(message: _84.PhpSettings): Uint8Array;
+            toProtoMsg(message: _84.PhpSettings): _84.PhpSettingsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        PythonSettings: {
+            typeUrl: string;
+            is(o: any): o is _84.PythonSettings;
+            isAmino(o: any): o is _84.PythonSettingsAmino;
+            encode(message: _84.PythonSettings, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.PythonSettings;
+            fromPartial(object: import("../helpers").DeepPartial<_84.PythonSettings>): _84.PythonSettings;
+            fromAmino(object: _84.PythonSettingsAmino): _84.PythonSettings;
+            toAmino(message: _84.PythonSettings): _84.PythonSettingsAmino;
+            fromAminoMsg(object: _84.PythonSettingsAminoMsg): _84.PythonSettings;
+            fromProtoMsg(message: _84.PythonSettingsProtoMsg): _84.PythonSettings;
+            toProto(message: _84.PythonSettings): Uint8Array;
+            toProtoMsg(message: _84.PythonSettings): _84.PythonSettingsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        PythonSettings_ExperimentalFeatures: {
+            typeUrl: string;
+            is(o: any): o is _84.PythonSettings_ExperimentalFeatures;
+            isAmino(o: any): o is _84.PythonSettings_ExperimentalFeaturesAmino;
+            encode(message: _84.PythonSettings_ExperimentalFeatures, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.PythonSettings_ExperimentalFeatures;
+            fromPartial(object: import("../helpers").DeepPartial<_84.PythonSettings_ExperimentalFeatures>): _84.PythonSettings_ExperimentalFeatures;
+            fromAmino(object: _84.PythonSettings_ExperimentalFeaturesAmino): _84.PythonSettings_ExperimentalFeatures;
+            toAmino(message: _84.PythonSettings_ExperimentalFeatures): _84.PythonSettings_ExperimentalFeaturesAmino;
+            fromAminoMsg(object: _84.PythonSettings_ExperimentalFeaturesAminoMsg): _84.PythonSettings_ExperimentalFeatures;
+            fromProtoMsg(message: _84.PythonSettings_ExperimentalFeaturesProtoMsg): _84.PythonSettings_ExperimentalFeatures;
+            toProto(message: _84.PythonSettings_ExperimentalFeatures): Uint8Array;
+            toProtoMsg(message: _84.PythonSettings_ExperimentalFeatures): _84.PythonSettings_ExperimentalFeaturesProtoMsg;
+            registerTypeUrl(): void;
+        };
+        NodeSettings: {
+            typeUrl: string;
+            is(o: any): o is _84.NodeSettings;
+            isAmino(o: any): o is _84.NodeSettingsAmino;
+            encode(message: _84.NodeSettings, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.NodeSettings;
+            fromPartial(object: import("../helpers").DeepPartial<_84.NodeSettings>): _84.NodeSettings;
+            fromAmino(object: _84.NodeSettingsAmino): _84.NodeSettings;
+            toAmino(message: _84.NodeSettings): _84.NodeSettingsAmino;
+            fromAminoMsg(object: _84.NodeSettingsAminoMsg): _84.NodeSettings;
+            fromProtoMsg(message: _84.NodeSettingsProtoMsg): _84.NodeSettings;
+            toProto(message: _84.NodeSettings): Uint8Array;
+            toProtoMsg(message: _84.NodeSettings): _84.NodeSettingsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        DotnetSettings_RenamedServicesEntry: {
+            encode(message: _84.DotnetSettings_RenamedServicesEntry, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.DotnetSettings_RenamedServicesEntry;
+            fromPartial(object: import("../helpers").DeepPartial<_84.DotnetSettings_RenamedServicesEntry>): _84.DotnetSettings_RenamedServicesEntry;
+            fromAmino(object: _84.DotnetSettings_RenamedServicesEntryAmino): _84.DotnetSettings_RenamedServicesEntry;
+            toAmino(message: _84.DotnetSettings_RenamedServicesEntry): _84.DotnetSettings_RenamedServicesEntryAmino;
+            fromAminoMsg(object: _84.DotnetSettings_RenamedServicesEntryAminoMsg): _84.DotnetSettings_RenamedServicesEntry;
+            fromProtoMsg(message: _84.DotnetSettings_RenamedServicesEntryProtoMsg): _84.DotnetSettings_RenamedServicesEntry;
+            toProto(message: _84.DotnetSettings_RenamedServicesEntry): Uint8Array;
+            registerTypeUrl(): void;
+        };
+        DotnetSettings_RenamedResourcesEntry: {
+            encode(message: _84.DotnetSettings_RenamedResourcesEntry, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.DotnetSettings_RenamedResourcesEntry;
+            fromPartial(object: import("../helpers").DeepPartial<_84.DotnetSettings_RenamedResourcesEntry>): _84.DotnetSettings_RenamedResourcesEntry;
+            fromAmino(object: _84.DotnetSettings_RenamedResourcesEntryAmino): _84.DotnetSettings_RenamedResourcesEntry;
+            toAmino(message: _84.DotnetSettings_RenamedResourcesEntry): _84.DotnetSettings_RenamedResourcesEntryAmino;
+            fromAminoMsg(object: _84.DotnetSettings_RenamedResourcesEntryAminoMsg): _84.DotnetSettings_RenamedResourcesEntry;
+            fromProtoMsg(message: _84.DotnetSettings_RenamedResourcesEntryProtoMsg): _84.DotnetSettings_RenamedResourcesEntry;
+            toProto(message: _84.DotnetSettings_RenamedResourcesEntry): Uint8Array;
+            registerTypeUrl(): void;
+        };
+        DotnetSettings: {
+            typeUrl: string;
+            is(o: any): o is _84.DotnetSettings;
+            isAmino(o: any): o is _84.DotnetSettingsAmino;
+            encode(message: _84.DotnetSettings, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.DotnetSettings;
+            fromPartial(object: import("../helpers").DeepPartial<_84.DotnetSettings>): _84.DotnetSettings;
+            fromAmino(object: _84.DotnetSettingsAmino): _84.DotnetSettings;
+            toAmino(message: _84.DotnetSettings): _84.DotnetSettingsAmino;
+            fromAminoMsg(object: _84.DotnetSettingsAminoMsg): _84.DotnetSettings;
+            fromProtoMsg(message: _84.DotnetSettingsProtoMsg): _84.DotnetSettings;
+            toProto(message: _84.DotnetSettings): Uint8Array;
+            toProtoMsg(message: _84.DotnetSettings): _84.DotnetSettingsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        RubySettings: {
+            typeUrl: string;
+            is(o: any): o is _84.RubySettings;
+            isAmino(o: any): o is _84.RubySettingsAmino;
+            encode(message: _84.RubySettings, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.RubySettings;
+            fromPartial(object: import("../helpers").DeepPartial<_84.RubySettings>): _84.RubySettings;
+            fromAmino(object: _84.RubySettingsAmino): _84.RubySettings;
+            toAmino(message: _84.RubySettings): _84.RubySettingsAmino;
+            fromAminoMsg(object: _84.RubySettingsAminoMsg): _84.RubySettings;
+            fromProtoMsg(message: _84.RubySettingsProtoMsg): _84.RubySettings;
+            toProto(message: _84.RubySettings): Uint8Array;
+            toProtoMsg(message: _84.RubySettings): _84.RubySettingsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        GoSettings_RenamedServicesEntry: {
+            encode(message: _84.GoSettings_RenamedServicesEntry, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.GoSettings_RenamedServicesEntry;
+            fromPartial(object: import("../helpers").DeepPartial<_84.GoSettings_RenamedServicesEntry>): _84.GoSettings_RenamedServicesEntry;
+            fromAmino(object: _84.GoSettings_RenamedServicesEntryAmino): _84.GoSettings_RenamedServicesEntry;
+            toAmino(message: _84.GoSettings_RenamedServicesEntry): _84.GoSettings_RenamedServicesEntryAmino;
+            fromAminoMsg(object: _84.GoSettings_RenamedServicesEntryAminoMsg): _84.GoSettings_RenamedServicesEntry;
+            fromProtoMsg(message: _84.GoSettings_RenamedServicesEntryProtoMsg): _84.GoSettings_RenamedServicesEntry;
+            toProto(message: _84.GoSettings_RenamedServicesEntry): Uint8Array;
+            registerTypeUrl(): void;
+        };
+        GoSettings: {
+            typeUrl: string;
+            is(o: any): o is _84.GoSettings;
+            isAmino(o: any): o is _84.GoSettingsAmino;
+            encode(message: _84.GoSettings, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.GoSettings;
+            fromPartial(object: import("../helpers").DeepPartial<_84.GoSettings>): _84.GoSettings;
+            fromAmino(object: _84.GoSettingsAmino): _84.GoSettings;
+            toAmino(message: _84.GoSettings): _84.GoSettingsAmino;
+            fromAminoMsg(object: _84.GoSettingsAminoMsg): _84.GoSettings;
+            fromProtoMsg(message: _84.GoSettingsProtoMsg): _84.GoSettings;
+            toProto(message: _84.GoSettings): Uint8Array;
+            toProtoMsg(message: _84.GoSettings): _84.GoSettingsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        MethodSettings: {
+            typeUrl: string;
+            is(o: any): o is _84.MethodSettings;
+            isAmino(o: any): o is _84.MethodSettingsAmino;
+            encode(message: _84.MethodSettings, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.MethodSettings;
+            fromPartial(object: import("../helpers").DeepPartial<_84.MethodSettings>): _84.MethodSettings;
+            fromAmino(object: _84.MethodSettingsAmino): _84.MethodSettings;
+            toAmino(message: _84.MethodSettings): _84.MethodSettingsAmino;
+            fromAminoMsg(object: _84.MethodSettingsAminoMsg): _84.MethodSettings;
+            fromProtoMsg(message: _84.MethodSettingsProtoMsg): _84.MethodSettings;
+            toProto(message: _84.MethodSettings): Uint8Array;
+            toProtoMsg(message: _84.MethodSettings): _84.MethodSettingsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        MethodSettings_LongRunning: {
+            typeUrl: string;
+            is(o: any): o is _84.MethodSettings_LongRunning;
+            isAmino(o: any): o is _84.MethodSettings_LongRunningAmino;
+            encode(message: _84.MethodSettings_LongRunning, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.MethodSettings_LongRunning;
+            fromPartial(object: import("../helpers").DeepPartial<_84.MethodSettings_LongRunning>): _84.MethodSettings_LongRunning;
+            fromAmino(object: _84.MethodSettings_LongRunningAmino): _84.MethodSettings_LongRunning;
+            toAmino(message: _84.MethodSettings_LongRunning): _84.MethodSettings_LongRunningAmino;
+            fromAminoMsg(object: _84.MethodSettings_LongRunningAminoMsg): _84.MethodSettings_LongRunning;
+            fromProtoMsg(message: _84.MethodSettings_LongRunningProtoMsg): _84.MethodSettings_LongRunning;
+            toProto(message: _84.MethodSettings_LongRunning): Uint8Array;
+            toProtoMsg(message: _84.MethodSettings_LongRunning): _84.MethodSettings_LongRunningProtoMsg;
+            registerTypeUrl(): void;
+        };
+        SelectiveGapicGeneration: {
+            typeUrl: string;
+            is(o: any): o is _84.SelectiveGapicGeneration;
+            isAmino(o: any): o is _84.SelectiveGapicGenerationAmino;
+            encode(message: _84.SelectiveGapicGeneration, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.SelectiveGapicGeneration;
+            fromPartial(object: import("../helpers").DeepPartial<_84.SelectiveGapicGeneration>): _84.SelectiveGapicGeneration;
+            fromAmino(object: _84.SelectiveGapicGenerationAmino): _84.SelectiveGapicGeneration;
+            toAmino(message: _84.SelectiveGapicGeneration): _84.SelectiveGapicGenerationAmino;
+            fromAminoMsg(object: _84.SelectiveGapicGenerationAminoMsg): _84.SelectiveGapicGeneration;
+            fromProtoMsg(message: _84.SelectiveGapicGenerationProtoMsg): _84.SelectiveGapicGeneration;
+            toProto(message: _84.SelectiveGapicGeneration): Uint8Array;
+            toProtoMsg(message: _84.SelectiveGapicGeneration): _84.SelectiveGapicGenerationProtoMsg;
+            registerTypeUrl(): void;
+        };
+        fieldBehaviorFromJSON(object: any): _83.FieldBehavior;
+        fieldBehaviorToJSON(object: _83.FieldBehavior): string;
+        FieldBehavior: typeof _83.FieldBehavior;
+        FieldBehaviorAmino: typeof _83.FieldBehavior;
+        fieldInfo_FormatFromJSON(object: any): _82.FieldInfo_Format;
+        fieldInfo_FormatToJSON(object: _82.FieldInfo_Format): string;
+        FieldInfo_Format: typeof _82.FieldInfo_Format;
+        FieldInfo_FormatAmino: typeof _82.FieldInfo_Format;
+        FieldInfo: {
+            typeUrl: string;
+            is(o: any): o is _82.FieldInfo;
+            isAmino(o: any): o is _82.FieldInfoAmino;
+            encode(message: _82.FieldInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _82.FieldInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_82.FieldInfo>): _82.FieldInfo;
+            fromAmino(object: _82.FieldInfoAmino): _82.FieldInfo;
+            toAmino(message: _82.FieldInfo): _82.FieldInfoAmino;
+            fromAminoMsg(object: _82.FieldInfoAminoMsg): _82.FieldInfo;
+            fromProtoMsg(message: _82.FieldInfoProtoMsg): _82.FieldInfo;
+            toProto(message: _82.FieldInfo): Uint8Array;
+            toProtoMsg(message: _82.FieldInfo): _82.FieldInfoProtoMsg;
+            registerTypeUrl(): void;
+        };
+        TypeReference: {
+            typeUrl: string;
+            is(o: any): o is _82.TypeReference;
+            isAmino(o: any): o is _82.TypeReferenceAmino;
+            encode(message: _82.TypeReference, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _82.TypeReference;
+            fromPartial(object: import("../helpers").DeepPartial<_82.TypeReference>): _82.TypeReference;
+            fromAmino(object: _82.TypeReferenceAmino): _82.TypeReference;
+            toAmino(message: _82.TypeReference): _82.TypeReferenceAmino;
+            fromAminoMsg(object: _82.TypeReferenceAminoMsg): _82.TypeReference;
+            fromProtoMsg(message: _82.TypeReferenceProtoMsg): _82.TypeReference;
+            toProto(message: _82.TypeReference): Uint8Array;
+            toProtoMsg(message: _82.TypeReference): _82.TypeReferenceProtoMsg;
+            registerTypeUrl(): void;
+        };
+        Http: {
+            typeUrl: string;
+            is(o: any): o is _81.Http;
+            isAmino(o: any): o is _81.HttpAmino;
+            encode(message: _81.Http, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _81.Http;
+            fromPartial(object: import("../helpers").DeepPartial<_81.Http>): _81.Http;
+            fromAmino(object: _81.HttpAmino): _81.Http;
+            toAmino(message: _81.Http): _81.HttpAmino;
+            fromAminoMsg(object: _81.HttpAminoMsg): _81.Http;
+            fromProtoMsg(message: _81.HttpProtoMsg): _81.Http;
+            toProto(message: _81.Http): Uint8Array;
+            toProtoMsg(message: _81.Http): _81.HttpProtoMsg;
+            registerTypeUrl(): void;
+        };
+        HttpRule: {
+            typeUrl: string;
+            is(o: any): o is _81.HttpRule;
+            isAmino(o: any): o is _81.HttpRuleAmino;
+            encode(message: _81.HttpRule, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _81.HttpRule;
+            fromPartial(object: import("../helpers").DeepPartial<_81.HttpRule>): _81.HttpRule;
+            fromAmino(object: _81.HttpRuleAmino): _81.HttpRule;
+            toAmino(message: _81.HttpRule): _81.HttpRuleAmino;
+            fromAminoMsg(object: _81.HttpRuleAminoMsg): _81.HttpRule;
+            fromProtoMsg(message: _81.HttpRuleProtoMsg): _81.HttpRule;
+            toProto(message: _81.HttpRule): Uint8Array;
+            toProtoMsg(message: _81.HttpRule): _81.HttpRuleProtoMsg;
+            registerTypeUrl(): void;
+        };
+        CustomHttpPattern: {
+            typeUrl: string;
+            is(o: any): o is _81.CustomHttpPattern;
+            isAmino(o: any): o is _81.CustomHttpPatternAmino;
+            encode(message: _81.CustomHttpPattern, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _81.CustomHttpPattern;
+            fromPartial(object: import("../helpers").DeepPartial<_81.CustomHttpPattern>): _81.CustomHttpPattern;
+            fromAmino(object: _81.CustomHttpPatternAmino): _81.CustomHttpPattern;
+            toAmino(message: _81.CustomHttpPattern): _81.CustomHttpPatternAmino;
+            fromAminoMsg(object: _81.CustomHttpPatternAminoMsg): _81.CustomHttpPattern;
+            fromProtoMsg(message: _81.CustomHttpPatternProtoMsg): _81.CustomHttpPattern;
+            toProto(message: _81.CustomHttpPattern): Uint8Array;
+            toProtoMsg(message: _81.CustomHttpPattern): _81.CustomHttpPatternProtoMsg;
+            registerTypeUrl(): void;
+        };
+        HttpBody: {
+            typeUrl: string;
+            is(o: any): o is _80.HttpBody;
+            isAmino(o: any): o is _80.HttpBodyAmino;
+            encode(message: _80.HttpBody, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _80.HttpBody;
+            fromPartial(object: import("../helpers").DeepPartial<_80.HttpBody>): _80.HttpBody;
+            fromAmino(object: _80.HttpBodyAmino): _80.HttpBody;
+            toAmino(message: _80.HttpBody): _80.HttpBodyAmino;
+            fromAminoMsg(object: _80.HttpBodyAminoMsg): _80.HttpBody;
+            fromProtoMsg(message: _80.HttpBodyProtoMsg): _80.HttpBody;
+            toProto(message: _80.HttpBody): Uint8Array;
+            toProtoMsg(message: _80.HttpBody): _80.HttpBodyProtoMsg;
+            registerTypeUrl(): void;
+        };
+        launchStageFromJSON(object: any): _79.LaunchStage;
+        launchStageToJSON(object: _79.LaunchStage): string;
+        LaunchStage: typeof _79.LaunchStage;
+        LaunchStageAmino: typeof _79.LaunchStage;
+        resourceDescriptor_HistoryFromJSON(object: any): _78.ResourceDescriptor_History;
+        resourceDescriptor_HistoryToJSON(object: _78.ResourceDescriptor_History): string;
+        resourceDescriptor_StyleFromJSON(object: any): _78.ResourceDescriptor_Style;
+        resourceDescriptor_StyleToJSON(object: _78.ResourceDescriptor_Style): string;
+        ResourceDescriptor_History: typeof _78.ResourceDescriptor_History;
+        ResourceDescriptor_HistoryAmino: typeof _78.ResourceDescriptor_History;
+        ResourceDescriptor_Style: typeof _78.ResourceDescriptor_Style;
+        ResourceDescriptor_StyleAmino: typeof _78.ResourceDescriptor_Style;
+        ResourceDescriptor: {
+            typeUrl: string;
+            is(o: any): o is _78.ResourceDescriptor;
+            isAmino(o: any): o is _78.ResourceDescriptorAmino;
+            encode(message: _78.ResourceDescriptor, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _78.ResourceDescriptor;
+            fromPartial(object: import("../helpers").DeepPartial<_78.ResourceDescriptor>): _78.ResourceDescriptor;
+            fromAmino(object: _78.ResourceDescriptorAmino): _78.ResourceDescriptor;
+            toAmino(message: _78.ResourceDescriptor): _78.ResourceDescriptorAmino;
+            fromAminoMsg(object: _78.ResourceDescriptorAminoMsg): _78.ResourceDescriptor;
+            fromProtoMsg(message: _78.ResourceDescriptorProtoMsg): _78.ResourceDescriptor;
+            toProto(message: _78.ResourceDescriptor): Uint8Array;
+            toProtoMsg(message: _78.ResourceDescriptor): _78.ResourceDescriptorProtoMsg;
+            registerTypeUrl(): void;
+        };
+        ResourceReference: {
+            typeUrl: string;
+            is(o: any): o is _78.ResourceReference;
+            isAmino(o: any): o is _78.ResourceReferenceAmino;
+            encode(message: _78.ResourceReference, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _78.ResourceReference;
+            fromPartial(object: import("../helpers").DeepPartial<_78.ResourceReference>): _78.ResourceReference;
+            fromAmino(object: _78.ResourceReferenceAmino): _78.ResourceReference;
+            toAmino(message: _78.ResourceReference): _78.ResourceReferenceAmino;
+            fromAminoMsg(object: _78.ResourceReferenceAminoMsg): _78.ResourceReference;
+            fromProtoMsg(message: _78.ResourceReferenceProtoMsg): _78.ResourceReference;
+            toProto(message: _78.ResourceReference): Uint8Array;
+            toProtoMsg(message: _78.ResourceReference): _78.ResourceReferenceProtoMsg;
+            registerTypeUrl(): void;
+        };
+        RoutingRule: {
+            typeUrl: string;
+            is(o: any): o is _77.RoutingRule;
+            isAmino(o: any): o is _77.RoutingRuleAmino;
+            encode(message: _77.RoutingRule, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _77.RoutingRule;
+            fromPartial(object: import("../helpers").DeepPartial<_77.RoutingRule>): _77.RoutingRule;
+            fromAmino(object: _77.RoutingRuleAmino): _77.RoutingRule;
+            toAmino(message: _77.RoutingRule): _77.RoutingRuleAmino;
+            fromAminoMsg(object: _77.RoutingRuleAminoMsg): _77.RoutingRule;
+            fromProtoMsg(message: _77.RoutingRuleProtoMsg): _77.RoutingRule;
+            toProto(message: _77.RoutingRule): Uint8Array;
+            toProtoMsg(message: _77.RoutingRule): _77.RoutingRuleProtoMsg;
+            registerTypeUrl(): void;
+        };
+        RoutingParameter: {
+            typeUrl: string;
+            is(o: any): o is _77.RoutingParameter;
+            isAmino(o: any): o is _77.RoutingParameterAmino;
+            encode(message: _77.RoutingParameter, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _77.RoutingParameter;
+            fromPartial(object: import("../helpers").DeepPartial<_77.RoutingParameter>): _77.RoutingParameter;
+            fromAmino(object: _77.RoutingParameterAmino): _77.RoutingParameter;
+            toAmino(message: _77.RoutingParameter): _77.RoutingParameterAmino;
+            fromAminoMsg(object: _77.RoutingParameterAminoMsg): _77.RoutingParameter;
+            fromProtoMsg(message: _77.RoutingParameterProtoMsg): _77.RoutingParameter;
+            toProto(message: _77.RoutingParameter): Uint8Array;
+            toProtoMsg(message: _77.RoutingParameter): _77.RoutingParameterProtoMsg;
+            registerTypeUrl(): void;
+        };
+        Visibility: {
+            typeUrl: string;
+            is(o: any): o is _76.Visibility;
+            isAmino(o: any): o is _76.VisibilityAmino;
+            encode(message: _76.Visibility, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _76.Visibility;
+            fromPartial(object: import("../helpers").DeepPartial<_76.Visibility>): _76.Visibility;
+            fromAmino(object: _76.VisibilityAmino): _76.Visibility;
+            toAmino(message: _76.Visibility): _76.VisibilityAmino;
+            fromAminoMsg(object: _76.VisibilityAminoMsg): _76.Visibility;
+            fromProtoMsg(message: _76.VisibilityProtoMsg): _76.Visibility;
+            toProto(message: _76.Visibility): Uint8Array;
+            toProtoMsg(message: _76.Visibility): _76.VisibilityProtoMsg;
+            registerTypeUrl(): void;
+        };
+        VisibilityRule: {
+            typeUrl: string;
+            is(o: any): o is _76.VisibilityRule;
+            isAmino(o: any): o is _76.VisibilityRuleAmino;
+            encode(message: _76.VisibilityRule, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _76.VisibilityRule;
+            fromPartial(object: import("../helpers").DeepPartial<_76.VisibilityRule>): _76.VisibilityRule;
+            fromAmino(object: _76.VisibilityRuleAmino): _76.VisibilityRule;
+            toAmino(message: _76.VisibilityRule): _76.VisibilityRuleAmino;
+            fromAminoMsg(object: _76.VisibilityRuleAminoMsg): _76.VisibilityRule;
+            fromProtoMsg(message: _76.VisibilityRuleProtoMsg): _76.VisibilityRule;
+            toProto(message: _76.VisibilityRule): Uint8Array;
+            toProtoMsg(message: _76.VisibilityRule): _76.VisibilityRuleProtoMsg;
+            registerTypeUrl(): void;
+        };
+    };
+}