@xpla/xpla-react 1.7.0-beta.0 → 1.7.0-beta.11

package/cosmos/autocli/v1/query.d.ts

@@ -0,0 +1,100 @@
+import { ModuleOptions, ModuleOptionsAmino } from "./options";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/** AppOptionsRequest is the RemoteInfoService/AppOptions request type. */
+export interface AppOptionsRequest {
+}
+export interface AppOptionsRequestProtoMsg {
+    typeUrl: "/cosmos.autocli.v1.AppOptionsRequest";
+    value: Uint8Array;
+}
+/** AppOptionsRequest is the RemoteInfoService/AppOptions request type. */
+export interface AppOptionsRequestAmino {
+}
+export interface AppOptionsRequestAminoMsg {
+    type: "cosmos-sdk/AppOptionsRequest";
+    value: AppOptionsRequestAmino;
+}
+export interface AppOptionsResponse_ModuleOptionsEntry {
+    key: string;
+    value?: ModuleOptions;
+}
+export interface AppOptionsResponse_ModuleOptionsEntryProtoMsg {
+    typeUrl: string;
+    value: Uint8Array;
+}
+export interface AppOptionsResponse_ModuleOptionsEntryAmino {
+    key: string;
+    value?: ModuleOptionsAmino;
+}
+export interface AppOptionsResponse_ModuleOptionsEntryAminoMsg {
+    type: string;
+    value: AppOptionsResponse_ModuleOptionsEntryAmino;
+}
+/** AppOptionsResponse is the RemoteInfoService/AppOptions response type. */
+export interface AppOptionsResponse {
+    /** module_options is a map of module name to autocli module options. */
+    moduleOptions: {
+        [key: string]: ModuleOptions;
+    };
+}
+export interface AppOptionsResponseProtoMsg {
+    typeUrl: "/cosmos.autocli.v1.AppOptionsResponse";
+    value: Uint8Array;
+}
+/** AppOptionsResponse is the RemoteInfoService/AppOptions response type. */
+export interface AppOptionsResponseAmino {
+    /** module_options is a map of module name to autocli module options. */
+    module_options: {
+        [key: string]: ModuleOptionsAmino;
+    };
+}
+export interface AppOptionsResponseAminoMsg {
+    type: "cosmos-sdk/AppOptionsResponse";
+    value: AppOptionsResponseAmino;
+}
+export declare const AppOptionsRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is AppOptionsRequest;
+    isAmino(o: any): o is AppOptionsRequestAmino;
+    encode(_: AppOptionsRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): AppOptionsRequest;
+    fromPartial(_: DeepPartial<AppOptionsRequest>): AppOptionsRequest;
+    fromAmino(_: AppOptionsRequestAmino): AppOptionsRequest;
+    toAmino(_: AppOptionsRequest): AppOptionsRequestAmino;
+    fromAminoMsg(object: AppOptionsRequestAminoMsg): AppOptionsRequest;
+    toAminoMsg(message: AppOptionsRequest): AppOptionsRequestAminoMsg;
+    fromProtoMsg(message: AppOptionsRequestProtoMsg): AppOptionsRequest;
+    toProto(message: AppOptionsRequest): Uint8Array;
+    toProtoMsg(message: AppOptionsRequest): AppOptionsRequestProtoMsg;
+    registerTypeUrl(): void;
+};
+export declare const AppOptionsResponse_ModuleOptionsEntry: {
+    encode(message: AppOptionsResponse_ModuleOptionsEntry, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): AppOptionsResponse_ModuleOptionsEntry;
+    fromPartial(object: DeepPartial<AppOptionsResponse_ModuleOptionsEntry>): AppOptionsResponse_ModuleOptionsEntry;
+    fromAmino(object: AppOptionsResponse_ModuleOptionsEntryAmino): AppOptionsResponse_ModuleOptionsEntry;
+    toAmino(message: AppOptionsResponse_ModuleOptionsEntry): AppOptionsResponse_ModuleOptionsEntryAmino;
+    fromAminoMsg(object: AppOptionsResponse_ModuleOptionsEntryAminoMsg): AppOptionsResponse_ModuleOptionsEntry;
+    fromProtoMsg(message: AppOptionsResponse_ModuleOptionsEntryProtoMsg): AppOptionsResponse_ModuleOptionsEntry;
+    toProto(message: AppOptionsResponse_ModuleOptionsEntry): Uint8Array;
+    registerTypeUrl(): void;
+};
+export declare const AppOptionsResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is AppOptionsResponse;
+    isAmino(o: any): o is AppOptionsResponseAmino;
+    encode(message: AppOptionsResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): AppOptionsResponse;
+    fromPartial(object: DeepPartial<AppOptionsResponse>): AppOptionsResponse;
+    fromAmino(object: AppOptionsResponseAmino): AppOptionsResponse;
+    toAmino(message: AppOptionsResponse): AppOptionsResponseAmino;
+    fromAminoMsg(object: AppOptionsResponseAminoMsg): AppOptionsResponse;
+    toAminoMsg(message: AppOptionsResponse): AppOptionsResponseAminoMsg;
+    fromProtoMsg(message: AppOptionsResponseProtoMsg): AppOptionsResponse;
+    toProto(message: AppOptionsResponse): Uint8Array;
+    toProtoMsg(message: AppOptionsResponse): AppOptionsResponseProtoMsg;
+    registerTypeUrl(): void;
+};

package/cosmos/autocli/v1/query.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppOptionsResponse = exports.AppOptionsResponse_ModuleOptionsEntry = exports.AppOptionsRequest = void 0;
+const options_1 = require("./options");
+const binary_1 = require("../../../binary");
+const helpers_1 = require("../../../helpers");
+function createBaseAppOptionsRequest() {
+    return {};
+}
+exports.AppOptionsRequest = {
+    typeUrl: "/cosmos.autocli.v1.AppOptionsRequest",
+    aminoType: "cosmos-sdk/AppOptionsRequest",
+    is(o) {
+        return o && o.$typeUrl === exports.AppOptionsRequest.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.AppOptionsRequest.typeUrl;
+    },
+    encode(_, writer = binary_1.BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseAppOptionsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseAppOptionsRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseAppOptionsRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.AppOptionsRequest.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/AppOptionsRequest",
+            value: exports.AppOptionsRequest.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.AppOptionsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return exports.AppOptionsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.autocli.v1.AppOptionsRequest",
+            value: exports.AppOptionsRequest.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseAppOptionsResponse_ModuleOptionsEntry() {
+    return {
+        key: "",
+        value: undefined
+    };
+}
+exports.AppOptionsResponse_ModuleOptionsEntry = {
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== undefined) {
+            options_1.ModuleOptions.encode(message.value, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseAppOptionsResponse_ModuleOptionsEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.string();
+                    break;
+                case 2:
+                    message.value = options_1.ModuleOptions.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseAppOptionsResponse_ModuleOptionsEntry();
+        message.key = object.key ?? "";
+        message.value = object.value !== undefined && object.value !== null ? options_1.ModuleOptions.fromPartial(object.value) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseAppOptionsResponse_ModuleOptionsEntry();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = object.key;
+        }
+        if (object.value !== undefined && object.value !== null) {
+            message.value = options_1.ModuleOptions.fromAmino(object.value);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key === "" ? undefined : message.key;
+        obj.value = message.value ? options_1.ModuleOptions.toAmino(message.value) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.AppOptionsResponse_ModuleOptionsEntry.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.AppOptionsResponse_ModuleOptionsEntry.decode(message.value);
+    },
+    toProto(message) {
+        return exports.AppOptionsResponse_ModuleOptionsEntry.encode(message).finish();
+    },
+    registerTypeUrl() {
+        options_1.ModuleOptions.registerTypeUrl();
+    }
+};
+function createBaseAppOptionsResponse() {
+    return {
+        moduleOptions: {}
+    };
+}
+exports.AppOptionsResponse = {
+    typeUrl: "/cosmos.autocli.v1.AppOptionsResponse",
+    aminoType: "cosmos-sdk/AppOptionsResponse",
+    is(o) {
+        return o && (o.$typeUrl === exports.AppOptionsResponse.typeUrl || (0, helpers_1.isSet)(o.moduleOptions));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.AppOptionsResponse.typeUrl || (0, helpers_1.isSet)(o.module_options));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        Object.entries(message.moduleOptions).forEach(([key, value]) => {
+            exports.AppOptionsResponse_ModuleOptionsEntry.encode({
+                key: key,
+                value
+            }, writer.uint32(10).fork()).ldelim();
+        });
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseAppOptionsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    const entry1 = exports.AppOptionsResponse_ModuleOptionsEntry.decode(reader, reader.uint32());
+                    if (entry1.value !== undefined) {
+                        message.moduleOptions[entry1.key] = entry1.value;
+                    }
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseAppOptionsResponse();
+        message.moduleOptions = Object.entries(object.moduleOptions ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = options_1.ModuleOptions.fromPartial(value);
+            }
+            return acc;
+        }, {});
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseAppOptionsResponse();
+        message.moduleOptions = Object.entries(object.module_options ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = options_1.ModuleOptions.fromAmino(value);
+            }
+            return acc;
+        }, {});
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.module_options = {};
+        if (message.moduleOptions) {
+            Object.entries(message.moduleOptions).forEach(([k, v]) => {
+                obj.module_options[k] = options_1.ModuleOptions.toAmino(v);
+            });
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.AppOptionsResponse.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/AppOptionsResponse",
+            value: exports.AppOptionsResponse.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.AppOptionsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.AppOptionsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.autocli.v1.AppOptionsResponse",
+            value: exports.AppOptionsResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        options_1.ModuleOptions.registerTypeUrl();
+    }
+};

package/cosmos/autocli/v1/query.rpc.func.d.ts

@@ -0,0 +1,3 @@
+import { RpcResolver } from "../../../helper-func-types";
+import { AppOptionsRequest, AppOptionsResponse } from "./query";
+export declare const createGetAppOptions: (clientResolver?: RpcResolver) => (request: AppOptionsRequest) => Promise<AppOptionsResponse>;

package/cosmos/autocli/v1/query.rpc.func.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGetAppOptions = void 0;
+const helper_func_types_1 = require("../../../helper-func-types");
+const query_1 = require("./query");
+const createGetAppOptions = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.AppOptionsRequest.encode,
+    decode: query_1.AppOptionsResponse.decode,
+    service: "cosmos.autocli.v1.Query",
+    method: "AppOptions",
+    clientResolver,
+    deps: [query_1.AppOptionsRequest, query_1.AppOptionsResponse]
+});
+exports.createGetAppOptions = createGetAppOptions;

package/cosmos/autocli/v1/query.rpc.react.d.ts

@@ -0,0 +1,2 @@
+import { AppOptionsRequest, AppOptionsResponse } from "./query";
+export declare const useGetAppOptions: <TData = AppOptionsResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../react-query").UseQueryParams<AppOptionsRequest, AppOptionsResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;

package/cosmos/autocli/v1/query.rpc.react.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGetAppOptions = void 0;
+const react_query_1 = require("../../../react-query");
+const query_rpc_func_1 = require("./query.rpc.func");
+exports.useGetAppOptions = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: query_rpc_func_1.createGetAppOptions,
+    queryKeyPrefix: "AppOptionsQuery"
+});

package/cosmos/bank/module/v1/module.d.ts

@@ -0,0 +1,63 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/** Module is the config object of the bank module. */
+export interface Module {
+    /**
+     * blocked_module_accounts_override configures exceptional module accounts which should be blocked from receiving
+     * funds. If left empty it defaults to the list of account names supplied in the auth module configuration as
+     * module_account_permissions
+     */
+    blockedModuleAccountsOverride: string[];
+    /** authority defines the custom module authority. If not set, defaults to the governance module. */
+    authority: string;
+    /**
+     * restrictions_order specifies the order of send restrictions and should be
+     * a list of module names which provide a send restriction instance. If no
+     * order is provided, then restrictions will be applied in alphabetical order
+     * of module names.
+     */
+    restrictionsOrder: string[];
+}
+export interface ModuleProtoMsg {
+    typeUrl: "/cosmos.bank.module.v1.Module";
+    value: Uint8Array;
+}
+/** Module is the config object of the bank module. */
+export interface ModuleAmino {
+    /**
+     * blocked_module_accounts_override configures exceptional module accounts which should be blocked from receiving
+     * funds. If left empty it defaults to the list of account names supplied in the auth module configuration as
+     * module_account_permissions
+     */
+    blocked_module_accounts_override: string[];
+    /** authority defines the custom module authority. If not set, defaults to the governance module. */
+    authority: string;
+    /**
+     * restrictions_order specifies the order of send restrictions and should be
+     * a list of module names which provide a send restriction instance. If no
+     * order is provided, then restrictions will be applied in alphabetical order
+     * of module names.
+     */
+    restrictions_order: string[];
+}
+export interface ModuleAminoMsg {
+    type: "cosmos-sdk/Module";
+    value: ModuleAmino;
+}
+export declare const Module: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is Module;
+    isAmino(o: any): o is ModuleAmino;
+    encode(message: Module, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Module;
+    fromPartial(object: DeepPartial<Module>): Module;
+    fromAmino(object: ModuleAmino): Module;
+    toAmino(message: Module): ModuleAmino;
+    fromAminoMsg(object: ModuleAminoMsg): Module;
+    toAminoMsg(message: Module): ModuleAminoMsg;
+    fromProtoMsg(message: ModuleProtoMsg): Module;
+    toProto(message: Module): Uint8Array;
+    toProtoMsg(message: Module): ModuleProtoMsg;
+    registerTypeUrl(): void;
+};

package/cosmos/bank/module/v1/module.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Module = void 0;
+const binary_1 = require("../../../../binary");
+function createBaseModule() {
+    return {
+        blockedModuleAccountsOverride: [],
+        authority: "",
+        restrictionsOrder: []
+    };
+}
+exports.Module = {
+    typeUrl: "/cosmos.bank.module.v1.Module",
+    aminoType: "cosmos-sdk/Module",
+    is(o) {
+        return o && (o.$typeUrl === exports.Module.typeUrl || Array.isArray(o.blockedModuleAccountsOverride) && (!o.blockedModuleAccountsOverride.length || typeof o.blockedModuleAccountsOverride[0] === "string") && typeof o.authority === "string" && Array.isArray(o.restrictionsOrder) && (!o.restrictionsOrder.length || typeof o.restrictionsOrder[0] === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.Module.typeUrl || Array.isArray(o.blocked_module_accounts_override) && (!o.blocked_module_accounts_override.length || typeof o.blocked_module_accounts_override[0] === "string") && typeof o.authority === "string" && Array.isArray(o.restrictions_order) && (!o.restrictions_order.length || typeof o.restrictions_order[0] === "string"));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        for (const v of message.blockedModuleAccountsOverride) {
+            writer.uint32(10).string(v);
+        }
+        if (message.authority !== "") {
+            writer.uint32(18).string(message.authority);
+        }
+        for (const v of message.restrictionsOrder) {
+            writer.uint32(26).string(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseModule();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.blockedModuleAccountsOverride.push(reader.string());
+                    break;
+                case 2:
+                    message.authority = reader.string();
+                    break;
+                case 3:
+                    message.restrictionsOrder.push(reader.string());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseModule();
+        message.blockedModuleAccountsOverride = object.blockedModuleAccountsOverride?.map(e => e) || [];
+        message.authority = object.authority ?? "";
+        message.restrictionsOrder = object.restrictionsOrder?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseModule();
+        message.blockedModuleAccountsOverride = object.blocked_module_accounts_override?.map(e => e) || [];
+        if (object.authority !== undefined && object.authority !== null) {
+            message.authority = object.authority;
+        }
+        message.restrictionsOrder = object.restrictions_order?.map(e => e) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.blockedModuleAccountsOverride) {
+            obj.blocked_module_accounts_override = message.blockedModuleAccountsOverride.map(e => e);
+        }
+        else {
+            obj.blocked_module_accounts_override = message.blockedModuleAccountsOverride;
+        }
+        obj.authority = message.authority === "" ? undefined : message.authority;
+        if (message.restrictionsOrder) {
+            obj.restrictions_order = message.restrictionsOrder.map(e => e);
+        }
+        else {
+            obj.restrictions_order = message.restrictionsOrder;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Module.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/Module",
+            value: exports.Module.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.Module.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Module.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.bank.module.v1.Module",
+            value: exports.Module.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};

package/cosmos/bank/v1beta1/authz.d.ts

@@ -0,0 +1,60 @@
+import { Coin, CoinAmino } from "../../base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * SendAuthorization allows the grantee to spend up to spend_limit coins from
+ * the granter's account.
+ *
+ * Since: cosmos-sdk 0.43
+ */
+export interface SendAuthorization {
+    spendLimit: Coin[];
+    /**
+     * allow_list specifies an optional list of addresses to whom the grantee can send tokens on behalf of the
+     * granter. If omitted, any recipient is allowed.
+     *
+     * Since: cosmos-sdk 0.47
+     */
+    allowList: string[];
+}
+export interface SendAuthorizationProtoMsg {
+    typeUrl: "/cosmos.bank.v1beta1.SendAuthorization";
+    value: Uint8Array;
+}
+/**
+ * SendAuthorization allows the grantee to spend up to spend_limit coins from
+ * the granter's account.
+ *
+ * Since: cosmos-sdk 0.43
+ */
+export interface SendAuthorizationAmino {
+    spend_limit: CoinAmino[];
+    /**
+     * allow_list specifies an optional list of addresses to whom the grantee can send tokens on behalf of the
+     * granter. If omitted, any recipient is allowed.
+     *
+     * Since: cosmos-sdk 0.47
+     */
+    allow_list: string[];
+}
+export interface SendAuthorizationAminoMsg {
+    type: "cosmos-sdk/SendAuthorization";
+    value: SendAuthorizationAmino;
+}
+export declare const SendAuthorization: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is SendAuthorization;
+    isAmino(o: any): o is SendAuthorizationAmino;
+    encode(message: SendAuthorization, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): SendAuthorization;
+    fromPartial(object: DeepPartial<SendAuthorization>): SendAuthorization;
+    fromAmino(object: SendAuthorizationAmino): SendAuthorization;
+    toAmino(message: SendAuthorization): SendAuthorizationAmino;
+    fromAminoMsg(object: SendAuthorizationAminoMsg): SendAuthorization;
+    toAminoMsg(message: SendAuthorization): SendAuthorizationAminoMsg;
+    fromProtoMsg(message: SendAuthorizationProtoMsg): SendAuthorization;
+    toProto(message: SendAuthorization): Uint8Array;
+    toProtoMsg(message: SendAuthorization): SendAuthorizationProtoMsg;
+    registerTypeUrl(): void;
+};