@gitopia/gitopiajs 0.0.4 → 0.0.6

package/dist/cosmos/bundle.js

@@ -0,0 +1,134 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cosmos = void 0;
+//@ts-nocheck
+const _2 = __importStar(require("./bank/v1beta1/bank"));
+const _3 = __importStar(require("./bank/v1beta1/query"));
+const _4 = __importStar(require("./base/query/v1beta1/pagination"));
+const _5 = __importStar(require("./base/v1beta1/coin"));
+const _6 = __importStar(require("./feegrant/v1beta1/feegrant"));
+const _7 = __importStar(require("./feegrant/v1beta1/query"));
+const _8 = __importStar(require("./gov/v1beta1/gov"));
+const _9 = __importStar(require("./gov/v1beta1/query"));
+const _10 = __importStar(require("./group/v1/query"));
+const _11 = __importStar(require("./group/v1/tx"));
+const _12 = __importStar(require("./group/v1/types"));
+const _13 = __importStar(require("./query/v1/query"));
+const _14 = __importStar(require("./upgrade/v1beta1/upgrade"));
+const _51 = __importStar(require("./group/v1/tx.amino"));
+const _52 = __importStar(require("./group/v1/tx.registry"));
+const _53 = __importStar(require("./bank/v1beta1/query.lcd"));
+const _54 = __importStar(require("./feegrant/v1beta1/query.lcd"));
+const _55 = __importStar(require("./gov/v1beta1/query.lcd"));
+const _56 = __importStar(require("./group/v1/query.lcd"));
+const _57 = __importStar(require("./bank/v1beta1/query.rpc.Query"));
+const _58 = __importStar(require("./feegrant/v1beta1/query.rpc.Query"));
+const _59 = __importStar(require("./gov/v1beta1/query.rpc.Query"));
+const _60 = __importStar(require("./group/v1/query.rpc.Query"));
+const _61 = __importStar(require("./group/v1/tx.rpc.msg"));
+const _77 = __importStar(require("./rpc.query"));
+const _78 = __importStar(require("./rpc.tx"));
+var cosmos;
+(function (cosmos) {
+    let bank;
+    (function (bank) {
+        bank.v1beta1 = {
+            ..._2,
+            ..._3,
+            ..._53,
+            ..._57
+        };
+    })(bank = cosmos.bank || (cosmos.bank = {}));
+    let base;
+    (function (base) {
+        let query;
+        (function (query) {
+            query.v1beta1 = {
+                ..._4
+            };
+        })(query = base.query || (base.query = {}));
+        base.v1beta1 = {
+            ..._5
+        };
+    })(base = cosmos.base || (cosmos.base = {}));
+    let feegrant;
+    (function (feegrant) {
+        feegrant.v1beta1 = {
+            ..._6,
+            ..._7,
+            ..._54,
+            ..._58
+        };
+    })(feegrant = cosmos.feegrant || (cosmos.feegrant = {}));
+    let gov;
+    (function (gov) {
+        gov.v1beta1 = {
+            ..._8,
+            ..._9,
+            ..._55,
+            ..._59
+        };
+    })(gov = cosmos.gov || (cosmos.gov = {}));
+    let group;
+    (function (group) {
+        group.v1 = {
+            ..._10,
+            ..._11,
+            ..._12,
+            ..._51,
+            ..._52,
+            ..._56,
+            ..._60,
+            ..._61
+        };
+    })(group = cosmos.group || (cosmos.group = {}));
+    let query;
+    (function (query) {
+        query.v1 = {
+            ..._13
+        };
+    })(query = cosmos.query || (cosmos.query = {}));
+    let upgrade;
+    (function (upgrade) {
+        upgrade.v1beta1 = {
+            ..._14
+        };
+    })(upgrade = cosmos.upgrade || (cosmos.upgrade = {}));
+    cosmos.ClientFactory = {
+        ..._77,
+        ..._78
+    };
+})(cosmos || (exports.cosmos = cosmos = {}));

package/dist/cosmos/client.d.ts

@@ -0,0 +1,84 @@
+import { GeneratedType, Registry, OfflineSigner } from "@cosmjs/proto-signing";
+import { AminoTypes, SigningStargateClient } from "@cosmjs/stargate";
+import { HttpEndpoint } from "@cosmjs/tendermint-rpc";
+export declare const cosmosAminoConverters: {
+    "/cosmos.group.v1.MsgCreateGroup": {
+        aminoType: string;
+        toAmino: (message: import("./group/v1/tx").MsgCreateGroup) => import("./group/v1/tx").MsgCreateGroupAmino;
+        fromAmino: (object: import("./group/v1/tx").MsgCreateGroupAmino) => import("./group/v1/tx").MsgCreateGroup;
+    };
+    "/cosmos.group.v1.MsgUpdateGroupMembers": {
+        aminoType: string;
+        toAmino: (message: import("./group/v1/tx").MsgUpdateGroupMembers) => import("./group/v1/tx").MsgUpdateGroupMembersAmino;
+        fromAmino: (object: import("./group/v1/tx").MsgUpdateGroupMembersAmino) => import("./group/v1/tx").MsgUpdateGroupMembers;
+    };
+    "/cosmos.group.v1.MsgUpdateGroupAdmin": {
+        aminoType: string;
+        toAmino: (message: import("./group/v1/tx").MsgUpdateGroupAdmin) => import("./group/v1/tx").MsgUpdateGroupAdminAmino;
+        fromAmino: (object: import("./group/v1/tx").MsgUpdateGroupAdminAmino) => import("./group/v1/tx").MsgUpdateGroupAdmin;
+    };
+    "/cosmos.group.v1.MsgUpdateGroupMetadata": {
+        aminoType: string;
+        toAmino: (message: import("./group/v1/tx").MsgUpdateGroupMetadata) => import("./group/v1/tx").MsgUpdateGroupMetadataAmino;
+        fromAmino: (object: import("./group/v1/tx").MsgUpdateGroupMetadataAmino) => import("./group/v1/tx").MsgUpdateGroupMetadata;
+    };
+    "/cosmos.group.v1.MsgCreateGroupPolicy": {
+        aminoType: string;
+        toAmino: (message: import("./group/v1/tx").MsgCreateGroupPolicy) => import("./group/v1/tx").MsgCreateGroupPolicyAmino;
+        fromAmino: (object: import("./group/v1/tx").MsgCreateGroupPolicyAmino) => import("./group/v1/tx").MsgCreateGroupPolicy;
+    };
+    "/cosmos.group.v1.MsgCreateGroupWithPolicy": {
+        aminoType: string;
+        toAmino: (message: import("./group/v1/tx").MsgCreateGroupWithPolicy) => import("./group/v1/tx").MsgCreateGroupWithPolicyAmino;
+        fromAmino: (object: import("./group/v1/tx").MsgCreateGroupWithPolicyAmino) => import("./group/v1/tx").MsgCreateGroupWithPolicy;
+    };
+    "/cosmos.group.v1.MsgUpdateGroupPolicyAdmin": {
+        aminoType: string;
+        toAmino: (message: import("./group/v1/tx").MsgUpdateGroupPolicyAdmin) => import("./group/v1/tx").MsgUpdateGroupPolicyAdminAmino;
+        fromAmino: (object: import("./group/v1/tx").MsgUpdateGroupPolicyAdminAmino) => import("./group/v1/tx").MsgUpdateGroupPolicyAdmin;
+    };
+    "/cosmos.group.v1.MsgUpdateGroupPolicyDecisionPolicy": {
+        aminoType: string;
+        toAmino: (message: import("./group/v1/tx").MsgUpdateGroupPolicyDecisionPolicy) => import("./group/v1/tx").MsgUpdateGroupPolicyDecisionPolicyAmino;
+        fromAmino: (object: import("./group/v1/tx").MsgUpdateGroupPolicyDecisionPolicyAmino) => import("./group/v1/tx").MsgUpdateGroupPolicyDecisionPolicy;
+    };
+    "/cosmos.group.v1.MsgUpdateGroupPolicyMetadata": {
+        aminoType: string;
+        toAmino: (message: import("./group/v1/tx").MsgUpdateGroupPolicyMetadata) => import("./group/v1/tx").MsgUpdateGroupPolicyMetadataAmino;
+        fromAmino: (object: import("./group/v1/tx").MsgUpdateGroupPolicyMetadataAmino) => import("./group/v1/tx").MsgUpdateGroupPolicyMetadata;
+    };
+    "/cosmos.group.v1.MsgSubmitProposal": {
+        aminoType: string;
+        toAmino: (message: import("./group/v1/tx").MsgSubmitProposal) => import("./group/v1/tx").MsgSubmitProposalAmino;
+        fromAmino: (object: import("./group/v1/tx").MsgSubmitProposalAmino) => import("./group/v1/tx").MsgSubmitProposal;
+    };
+    "/cosmos.group.v1.MsgWithdrawProposal": {
+        aminoType: string;
+        toAmino: (message: import("./group/v1/tx").MsgWithdrawProposal) => import("./group/v1/tx").MsgWithdrawProposalAmino;
+        fromAmino: (object: import("./group/v1/tx").MsgWithdrawProposalAmino) => import("./group/v1/tx").MsgWithdrawProposal;
+    };
+    "/cosmos.group.v1.MsgVote": {
+        aminoType: string;
+        toAmino: (message: import("./group/v1/tx").MsgVote) => import("./group/v1/tx").MsgVoteAmino;
+        fromAmino: (object: import("./group/v1/tx").MsgVoteAmino) => import("./group/v1/tx").MsgVote;
+    };
+    "/cosmos.group.v1.MsgExec": {
+        aminoType: string;
+        toAmino: (message: import("./group/v1/tx").MsgExec) => import("./group/v1/tx").MsgExecAmino;
+        fromAmino: (object: import("./group/v1/tx").MsgExecAmino) => import("./group/v1/tx").MsgExec;
+    };
+    "/cosmos.group.v1.MsgLeaveGroup": {
+        aminoType: string;
+        toAmino: (message: import("./group/v1/tx").MsgLeaveGroup) => import("./group/v1/tx").MsgLeaveGroupAmino;
+        fromAmino: (object: import("./group/v1/tx").MsgLeaveGroupAmino) => import("./group/v1/tx").MsgLeaveGroup;
+    };
+};
+export declare const cosmosProtoRegistry: ReadonlyArray<[string, GeneratedType]>;
+export declare const getSigningCosmosClientOptions: () => {
+    registry: Registry;
+    aminoTypes: AminoTypes;
+};
+export declare const getSigningCosmosClient: ({ rpcEndpoint, signer }: {
+    rpcEndpoint: string | HttpEndpoint;
+    signer: OfflineSigner;
+}) => Promise<SigningStargateClient>;

package/dist/cosmos/client.js

@@ -0,0 +1,65 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSigningCosmosClient = exports.getSigningCosmosClientOptions = exports.cosmosProtoRegistry = exports.cosmosAminoConverters = void 0;
+//@ts-nocheck
+const proto_signing_1 = require("@cosmjs/proto-signing");
+const stargate_1 = require("@cosmjs/stargate");
+const cosmosGroupV1TxRegistry = __importStar(require("./group/v1/tx.registry"));
+const cosmosGroupV1TxAmino = __importStar(require("./group/v1/tx.amino"));
+exports.cosmosAminoConverters = {
+    ...cosmosGroupV1TxAmino.AminoConverter
+};
+exports.cosmosProtoRegistry = [...cosmosGroupV1TxRegistry.registry];
+const getSigningCosmosClientOptions = () => {
+    const registry = new proto_signing_1.Registry([...exports.cosmosProtoRegistry]);
+    const aminoTypes = new stargate_1.AminoTypes({
+        ...exports.cosmosAminoConverters
+    });
+    return {
+        registry,
+        aminoTypes
+    };
+};
+exports.getSigningCosmosClientOptions = getSigningCosmosClientOptions;
+const getSigningCosmosClient = async ({ rpcEndpoint, signer }) => {
+    const { registry, aminoTypes } = (0, exports.getSigningCosmosClientOptions)();
+    const client = await stargate_1.SigningStargateClient.connectWithSigner(rpcEndpoint, signer, {
+        registry: registry,
+        aminoTypes
+    });
+    return client;
+};
+exports.getSigningCosmosClient = getSigningCosmosClient;

package/dist/cosmos/feegrant/v1beta1/feegrant.d.ts

@@ -0,0 +1,245 @@
+import { Coin, CoinAmino, CoinSDKType } from "../../base/v1beta1/coin";
+import { Duration, DurationAmino, DurationSDKType } from "../../../google/protobuf/duration";
+import { Any, AnyProtoMsg, AnyAmino, AnySDKType } from "../../../google/protobuf/any";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/**
+ * BasicAllowance implements Allowance with a one-time grant of coins
+ * that optionally expires. The grantee can use up to SpendLimit to cover fees.
+ */
+export interface BasicAllowance {
+    $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
+    /**
+     * spend_limit specifies the maximum amount of coins that can be spent
+     * by this allowance and will be updated as coins are spent. If it is
+     * empty, there is no spend limit and any amount of coins can be spent.
+     */
+    spendLimit: Coin[];
+    /** expiration specifies an optional time when this allowance expires */
+    expiration?: Date;
+}
+export interface BasicAllowanceProtoMsg {
+    typeUrl: "/cosmos.feegrant.v1beta1.BasicAllowance";
+    value: Uint8Array;
+}
+/**
+ * BasicAllowance implements Allowance with a one-time grant of coins
+ * that optionally expires. The grantee can use up to SpendLimit to cover fees.
+ */
+export interface BasicAllowanceAmino {
+    /**
+     * spend_limit specifies the maximum amount of coins that can be spent
+     * by this allowance and will be updated as coins are spent. If it is
+     * empty, there is no spend limit and any amount of coins can be spent.
+     */
+    spend_limit: CoinAmino[];
+    /** expiration specifies an optional time when this allowance expires */
+    expiration?: string;
+}
+export interface BasicAllowanceAminoMsg {
+    type: "cosmos-sdk/BasicAllowance";
+    value: BasicAllowanceAmino;
+}
+/**
+ * BasicAllowance implements Allowance with a one-time grant of coins
+ * that optionally expires. The grantee can use up to SpendLimit to cover fees.
+ */
+export interface BasicAllowanceSDKType {
+    $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
+    spend_limit: CoinSDKType[];
+    expiration?: Date;
+}
+/**
+ * PeriodicAllowance extends Allowance to allow for both a maximum cap,
+ * as well as a limit per time period.
+ */
+export interface PeriodicAllowance {
+    $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
+    /** basic specifies a struct of `BasicAllowance` */
+    basic: BasicAllowance;
+    /**
+     * period specifies the time duration in which period_spend_limit coins can
+     * be spent before that allowance is reset
+     */
+    period: Duration;
+    /**
+     * period_spend_limit specifies the maximum number of coins that can be spent
+     * in the period
+     */
+    periodSpendLimit: Coin[];
+    /** period_can_spend is the number of coins left to be spent before the period_reset time */
+    periodCanSpend: Coin[];
+    /**
+     * period_reset is the time at which this period resets and a new one begins,
+     * it is calculated from the start time of the first transaction after the
+     * last period ended
+     */
+    periodReset: Date;
+}
+export interface PeriodicAllowanceProtoMsg {
+    typeUrl: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
+    value: Uint8Array;
+}
+/**
+ * PeriodicAllowance extends Allowance to allow for both a maximum cap,
+ * as well as a limit per time period.
+ */
+export interface PeriodicAllowanceAmino {
+    /** basic specifies a struct of `BasicAllowance` */
+    basic: BasicAllowanceAmino;
+    /**
+     * period specifies the time duration in which period_spend_limit coins can
+     * be spent before that allowance is reset
+     */
+    period: DurationAmino;
+    /**
+     * period_spend_limit specifies the maximum number of coins that can be spent
+     * in the period
+     */
+    period_spend_limit: CoinAmino[];
+    /** period_can_spend is the number of coins left to be spent before the period_reset time */
+    period_can_spend: CoinAmino[];
+    /**
+     * period_reset is the time at which this period resets and a new one begins,
+     * it is calculated from the start time of the first transaction after the
+     * last period ended
+     */
+    period_reset: string;
+}
+export interface PeriodicAllowanceAminoMsg {
+    type: "cosmos-sdk/PeriodicAllowance";
+    value: PeriodicAllowanceAmino;
+}
+/**
+ * PeriodicAllowance extends Allowance to allow for both a maximum cap,
+ * as well as a limit per time period.
+ */
+export interface PeriodicAllowanceSDKType {
+    $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
+    basic: BasicAllowanceSDKType;
+    period: DurationSDKType;
+    period_spend_limit: CoinSDKType[];
+    period_can_spend: CoinSDKType[];
+    period_reset: Date;
+}
+/** AllowedMsgAllowance creates allowance only for specified message types. */
+export interface AllowedMsgAllowance {
+    $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
+    /** allowance can be any of basic and periodic fee allowance. */
+    allowance?: BasicAllowance | PeriodicAllowance | AllowedMsgAllowance | Any | undefined;
+    /** allowed_messages are the messages for which the grantee has the access. */
+    allowedMessages: string[];
+}
+export interface AllowedMsgAllowanceProtoMsg {
+    typeUrl: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
+    value: Uint8Array;
+}
+export type AllowedMsgAllowanceEncoded = Omit<AllowedMsgAllowance, "allowance"> & {
+    /** allowance can be any of basic and periodic fee allowance. */ allowance?: BasicAllowanceProtoMsg | PeriodicAllowanceProtoMsg | AllowedMsgAllowanceProtoMsg | AnyProtoMsg | undefined;
+};
+/** AllowedMsgAllowance creates allowance only for specified message types. */
+export interface AllowedMsgAllowanceAmino {
+    /** allowance can be any of basic and periodic fee allowance. */
+    allowance?: AnyAmino;
+    /** allowed_messages are the messages for which the grantee has the access. */
+    allowed_messages?: string[];
+}
+export interface AllowedMsgAllowanceAminoMsg {
+    type: "cosmos-sdk/AllowedMsgAllowance";
+    value: AllowedMsgAllowanceAmino;
+}
+/** AllowedMsgAllowance creates allowance only for specified message types. */
+export interface AllowedMsgAllowanceSDKType {
+    $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
+    allowance?: BasicAllowanceSDKType | PeriodicAllowanceSDKType | AllowedMsgAllowanceSDKType | AnySDKType | undefined;
+    allowed_messages: string[];
+}
+/** Grant is stored in the KVStore to record a grant with full context */
+export interface Grant {
+    /** granter is the address of the user granting an allowance of their funds. */
+    granter: string;
+    /** grantee is the address of the user being granted an allowance of another user's funds. */
+    grantee: string;
+    /** allowance can be any of basic, periodic, allowed fee allowance. */
+    allowance?: BasicAllowance | PeriodicAllowance | AllowedMsgAllowance | Any | undefined;
+}
+export interface GrantProtoMsg {
+    typeUrl: "/cosmos.feegrant.v1beta1.Grant";
+    value: Uint8Array;
+}
+export type GrantEncoded = Omit<Grant, "allowance"> & {
+    /** allowance can be any of basic, periodic, allowed fee allowance. */ allowance?: BasicAllowanceProtoMsg | PeriodicAllowanceProtoMsg | AllowedMsgAllowanceProtoMsg | AnyProtoMsg | undefined;
+};
+/** Grant is stored in the KVStore to record a grant with full context */
+export interface GrantAmino {
+    /** granter is the address of the user granting an allowance of their funds. */
+    granter?: string;
+    /** grantee is the address of the user being granted an allowance of another user's funds. */
+    grantee?: string;
+    /** allowance can be any of basic, periodic, allowed fee allowance. */
+    allowance?: AnyAmino;
+}
+export interface GrantAminoMsg {
+    type: "cosmos-sdk/Grant";
+    value: GrantAmino;
+}
+/** Grant is stored in the KVStore to record a grant with full context */
+export interface GrantSDKType {
+    granter: string;
+    grantee: string;
+    allowance?: BasicAllowanceSDKType | PeriodicAllowanceSDKType | AllowedMsgAllowanceSDKType | AnySDKType | undefined;
+}
+export declare const BasicAllowance: {
+    typeUrl: string;
+    encode(message: BasicAllowance, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): BasicAllowance;
+    fromPartial(object: Partial<BasicAllowance>): BasicAllowance;
+    fromAmino(object: BasicAllowanceAmino): BasicAllowance;
+    toAmino(message: BasicAllowance): BasicAllowanceAmino;
+    fromAminoMsg(object: BasicAllowanceAminoMsg): BasicAllowance;
+    toAminoMsg(message: BasicAllowance): BasicAllowanceAminoMsg;
+    fromProtoMsg(message: BasicAllowanceProtoMsg): BasicAllowance;
+    toProto(message: BasicAllowance): Uint8Array;
+    toProtoMsg(message: BasicAllowance): BasicAllowanceProtoMsg;
+};
+export declare const PeriodicAllowance: {
+    typeUrl: string;
+    encode(message: PeriodicAllowance, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PeriodicAllowance;
+    fromPartial(object: Partial<PeriodicAllowance>): PeriodicAllowance;
+    fromAmino(object: PeriodicAllowanceAmino): PeriodicAllowance;
+    toAmino(message: PeriodicAllowance): PeriodicAllowanceAmino;
+    fromAminoMsg(object: PeriodicAllowanceAminoMsg): PeriodicAllowance;
+    toAminoMsg(message: PeriodicAllowance): PeriodicAllowanceAminoMsg;
+    fromProtoMsg(message: PeriodicAllowanceProtoMsg): PeriodicAllowance;
+    toProto(message: PeriodicAllowance): Uint8Array;
+    toProtoMsg(message: PeriodicAllowance): PeriodicAllowanceProtoMsg;
+};
+export declare const AllowedMsgAllowance: {
+    typeUrl: string;
+    encode(message: AllowedMsgAllowance, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): AllowedMsgAllowance;
+    fromPartial(object: Partial<AllowedMsgAllowance>): AllowedMsgAllowance;
+    fromAmino(object: AllowedMsgAllowanceAmino): AllowedMsgAllowance;
+    toAmino(message: AllowedMsgAllowance): AllowedMsgAllowanceAmino;
+    fromAminoMsg(object: AllowedMsgAllowanceAminoMsg): AllowedMsgAllowance;
+    toAminoMsg(message: AllowedMsgAllowance): AllowedMsgAllowanceAminoMsg;
+    fromProtoMsg(message: AllowedMsgAllowanceProtoMsg): AllowedMsgAllowance;
+    toProto(message: AllowedMsgAllowance): Uint8Array;
+    toProtoMsg(message: AllowedMsgAllowance): AllowedMsgAllowanceProtoMsg;
+};
+export declare const Grant: {
+    typeUrl: string;
+    encode(message: Grant, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Grant;
+    fromPartial(object: Partial<Grant>): Grant;
+    fromAmino(object: GrantAmino): Grant;
+    toAmino(message: Grant): GrantAmino;
+    fromAminoMsg(object: GrantAminoMsg): Grant;
+    toAminoMsg(message: Grant): GrantAminoMsg;
+    fromProtoMsg(message: GrantProtoMsg): Grant;
+    toProto(message: Grant): Uint8Array;
+    toProtoMsg(message: Grant): GrantProtoMsg;
+};
+export declare const Cosmos_feegrantv1beta1FeeAllowanceI_InterfaceDecoder: (input: BinaryReader | Uint8Array) => BasicAllowance | PeriodicAllowance | AllowedMsgAllowance | Any;
+export declare const Cosmos_feegrantv1beta1FeeAllowanceI_FromAmino: (content: AnyAmino) => Any;
+export declare const Cosmos_feegrantv1beta1FeeAllowanceI_ToAmino: (content: Any) => AnyAmino;