import { Coin } from '../../../cosmos/base/v1beta1/coin';
import Long from 'long';
import _m0 from 'protobufjs/minimal';
export declare const protobufPackage = "bitsong.fantoken";
/** MsgIssue defines a message for issuing a new fan token */
export interface MsgIssue {
    $type: 'bitsong.fantoken.MsgIssue';
    /** symbol which corresponds to the symbol of the fan token. It is a string and cannot change for the whole life of the fan token */
    symbol: string;
    /** name which corresponds to the name of the fan token. It is a string and cannot change for the whole life of the fan token */
    name: string;
    /** max_supply that represents the maximum number of possible mintable tokens. It is an integer number, expressed in micro unit 10^6 */
    maxSupply: string;
    /** authority which is who can set a new uri metadata */
    authority: string;
    /** minter who is who can mint new fantoken and disable the minter process, the minter key also pay the gas fee */
    minter: string;
    /** URI which is the current uri of the fan token. It is a string can change during the fan token lifecycle thanks to the MsgEdit */
    uri: string;
}
/** MsgIssueResponse defines the MsgIssue response type */
export interface MsgIssueResponse {
    $type: 'bitsong.fantoken.MsgIssueResponse';
}
/** MsgDisableMint defines a message for disable the mint function */
export interface MsgDisableMint {
    $type: 'bitsong.fantoken.MsgDisableMint';
    denom: string;
    minter: string;
}
/** MsgDisableMintResponse defines the MsgDisableMint response type */
export interface MsgDisableMintResponse {
    $type: 'bitsong.fantoken.MsgDisableMintResponse';
}
/** MsgMint defines a message for minting a new fan token */
export interface MsgMint {
    $type: 'bitsong.fantoken.MsgMint';
    recipient: string;
    /** coin mean the amount + denom, eg: 10000ftFADJID34MCDM */
    coin?: Coin;
    minter: string;
}
/** MsgMintResponse defines the MsgMint response type */
export interface MsgMintResponse {
    $type: 'bitsong.fantoken.MsgMintResponse';
}
/** MsgBurn defines a message for burning some fan tokens */
export interface MsgBurn {
    $type: 'bitsong.fantoken.MsgBurn';
    /** coin mean the amount + denom, eg: 10000ftFADJID34MCDM */
    coin?: Coin;
    sender: string;
}
/** MsgBurnResponse defines the MsgBurn response type */
export interface MsgBurnResponse {
    $type: 'bitsong.fantoken.MsgBurnResponse';
}
/** MsgSetMinter defines a message for changing the fan token minter address */
export interface MsgSetMinter {
    $type: 'bitsong.fantoken.MsgSetMinter';
    /** denom the fan token denom */
    denom: string;
    /** old_minter, the actual minter */
    oldMinter: string;
    /** new_minter, the new fan token minter */
    newMinter: string;
}
/** MsgSetMinterResponse defines the MsgTransferAuthority response type */
export interface MsgSetMinterResponse {
    $type: 'bitsong.fantoken.MsgSetMinterResponse';
}
/** MsgSetAuthority defines a message for changing the fan token minter address */
export interface MsgSetAuthority {
    $type: 'bitsong.fantoken.MsgSetAuthority';
    /** denom the fan token denom */
    denom: string;
    /** old_authority, the actual metadata authority */
    oldAuthority: string;
    /** new_authority, the new fan token metadata authority */
    newAuthority: string;
}
/** MsgSetAuthorityResponse defines the MsgTransferAuthority response type */
export interface MsgSetAuthorityResponse {
    $type: 'bitsong.fantoken.MsgSetAuthorityResponse';
}
export interface MsgSetUri {
    $type: 'bitsong.fantoken.MsgSetUri';
    authority: string;
    denom: string;
    uri: string;
}
export interface MsgSetUriResponse {
    $type: 'bitsong.fantoken.MsgSetUriResponse';
}
export declare const MsgIssue: {
    $type: "bitsong.fantoken.MsgIssue";
    encode(message: MsgIssue, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): MsgIssue;
    fromJSON(object: any): MsgIssue;
    toJSON(message: MsgIssue): unknown;
    fromPartial<I extends {
        symbol?: string | undefined;
        name?: string | undefined;
        maxSupply?: string | undefined;
        authority?: string | undefined;
        minter?: string | undefined;
        uri?: string | undefined;
    } & {
        symbol?: string | undefined;
        name?: string | undefined;
        maxSupply?: string | undefined;
        authority?: string | undefined;
        minter?: string | undefined;
        uri?: string | undefined;
    } & { [K in Exclude<keyof I, "symbol" | "$type" | "name" | "maxSupply" | "authority" | "minter" | "uri">]: never; }>(object: I): MsgIssue;
};
export declare const MsgIssueResponse: {
    $type: "bitsong.fantoken.MsgIssueResponse";
    encode(_: MsgIssueResponse, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): MsgIssueResponse;
    fromJSON(_: any): MsgIssueResponse;
    toJSON(_: MsgIssueResponse): unknown;
    fromPartial<I extends {} & {} & { [K in Exclude<keyof I, "$type">]: never; }>(_: I): MsgIssueResponse;
};
export declare const MsgDisableMint: {
    $type: "bitsong.fantoken.MsgDisableMint";
    encode(message: MsgDisableMint, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): MsgDisableMint;
    fromJSON(object: any): MsgDisableMint;
    toJSON(message: MsgDisableMint): unknown;
    fromPartial<I extends {
        denom?: string | undefined;
        minter?: string | undefined;
    } & {
        denom?: string | undefined;
        minter?: string | undefined;
    } & { [K in Exclude<keyof I, "$type" | "denom" | "minter">]: never; }>(object: I): MsgDisableMint;
};
export declare const MsgDisableMintResponse: {
    $type: "bitsong.fantoken.MsgDisableMintResponse";
    encode(_: MsgDisableMintResponse, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): MsgDisableMintResponse;
    fromJSON(_: any): MsgDisableMintResponse;
    toJSON(_: MsgDisableMintResponse): unknown;
    fromPartial<I extends {} & {} & { [K in Exclude<keyof I, "$type">]: never; }>(_: I): MsgDisableMintResponse;
};
export declare const MsgMint: {
    $type: "bitsong.fantoken.MsgMint";
    encode(message: MsgMint, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): MsgMint;
    fromJSON(object: any): MsgMint;
    toJSON(message: MsgMint): unknown;
    fromPartial<I extends {
        minter?: string | undefined;
        recipient?: string | undefined;
        coin?: {
            denom?: string | undefined;
            amount?: string | undefined;
        } | undefined;
    } & {
        minter?: string | undefined;
        recipient?: string | undefined;
        coin?: ({
            denom?: string | undefined;
            amount?: string | undefined;
        } & {
            denom?: string | undefined;
            amount?: string | undefined;
        } & { [K in Exclude<keyof I["coin"], "$type" | "denom" | "amount">]: never; }) | undefined;
    } & { [K_1 in Exclude<keyof I, "$type" | "minter" | "recipient" | "coin">]: never; }>(object: I): MsgMint;
};
export declare const MsgMintResponse: {
    $type: "bitsong.fantoken.MsgMintResponse";
    encode(_: MsgMintResponse, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): MsgMintResponse;
    fromJSON(_: any): MsgMintResponse;
    toJSON(_: MsgMintResponse): unknown;
    fromPartial<I extends {} & {} & { [K in Exclude<keyof I, "$type">]: never; }>(_: I): MsgMintResponse;
};
export declare const MsgBurn: {
    $type: "bitsong.fantoken.MsgBurn";
    encode(message: MsgBurn, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): MsgBurn;
    fromJSON(object: any): MsgBurn;
    toJSON(message: MsgBurn): unknown;
    fromPartial<I extends {
        coin?: {
            denom?: string | undefined;
            amount?: string | undefined;
        } | undefined;
        sender?: string | undefined;
    } & {
        coin?: ({
            denom?: string | undefined;
            amount?: string | undefined;
        } & {
            denom?: string | undefined;
            amount?: string | undefined;
        } & { [K in Exclude<keyof I["coin"], "$type" | "denom" | "amount">]: never; }) | undefined;
        sender?: string | undefined;
    } & { [K_1 in Exclude<keyof I, "$type" | "coin" | "sender">]: never; }>(object: I): MsgBurn;
};
export declare const MsgBurnResponse: {
    $type: "bitsong.fantoken.MsgBurnResponse";
    encode(_: MsgBurnResponse, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): MsgBurnResponse;
    fromJSON(_: any): MsgBurnResponse;
    toJSON(_: MsgBurnResponse): unknown;
    fromPartial<I extends {} & {} & { [K in Exclude<keyof I, "$type">]: never; }>(_: I): MsgBurnResponse;
};
export declare const MsgSetMinter: {
    $type: "bitsong.fantoken.MsgSetMinter";
    encode(message: MsgSetMinter, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): MsgSetMinter;
    fromJSON(object: any): MsgSetMinter;
    toJSON(message: MsgSetMinter): unknown;
    fromPartial<I extends {
        denom?: string | undefined;
        oldMinter?: string | undefined;
        newMinter?: string | undefined;
    } & {
        denom?: string | undefined;
        oldMinter?: string | undefined;
        newMinter?: string | undefined;
    } & { [K in Exclude<keyof I, "$type" | "denom" | "oldMinter" | "newMinter">]: never; }>(object: I): MsgSetMinter;
};
export declare const MsgSetMinterResponse: {
    $type: "bitsong.fantoken.MsgSetMinterResponse";
    encode(_: MsgSetMinterResponse, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): MsgSetMinterResponse;
    fromJSON(_: any): MsgSetMinterResponse;
    toJSON(_: MsgSetMinterResponse): unknown;
    fromPartial<I extends {} & {} & { [K in Exclude<keyof I, "$type">]: never; }>(_: I): MsgSetMinterResponse;
};
export declare const MsgSetAuthority: {
    $type: "bitsong.fantoken.MsgSetAuthority";
    encode(message: MsgSetAuthority, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): MsgSetAuthority;
    fromJSON(object: any): MsgSetAuthority;
    toJSON(message: MsgSetAuthority): unknown;
    fromPartial<I extends {
        denom?: string | undefined;
        oldAuthority?: string | undefined;
        newAuthority?: string | undefined;
    } & {
        denom?: string | undefined;
        oldAuthority?: string | undefined;
        newAuthority?: string | undefined;
    } & { [K in Exclude<keyof I, "$type" | "denom" | "oldAuthority" | "newAuthority">]: never; }>(object: I): MsgSetAuthority;
};
export declare const MsgSetAuthorityResponse: {
    $type: "bitsong.fantoken.MsgSetAuthorityResponse";
    encode(_: MsgSetAuthorityResponse, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): MsgSetAuthorityResponse;
    fromJSON(_: any): MsgSetAuthorityResponse;
    toJSON(_: MsgSetAuthorityResponse): unknown;
    fromPartial<I extends {} & {} & { [K in Exclude<keyof I, "$type">]: never; }>(_: I): MsgSetAuthorityResponse;
};
export declare const MsgSetUri: {
    $type: "bitsong.fantoken.MsgSetUri";
    encode(message: MsgSetUri, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): MsgSetUri;
    fromJSON(object: any): MsgSetUri;
    toJSON(message: MsgSetUri): unknown;
    fromPartial<I extends {
        denom?: string | undefined;
        authority?: string | undefined;
        uri?: string | undefined;
    } & {
        denom?: string | undefined;
        authority?: string | undefined;
        uri?: string | undefined;
    } & { [K in Exclude<keyof I, "$type" | "denom" | "authority" | "uri">]: never; }>(object: I): MsgSetUri;
};
export declare const MsgSetUriResponse: {
    $type: "bitsong.fantoken.MsgSetUriResponse";
    encode(_: MsgSetUriResponse, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): MsgSetUriResponse;
    fromJSON(_: any): MsgSetUriResponse;
    toJSON(_: MsgSetUriResponse): unknown;
    fromPartial<I extends {} & {} & { [K in Exclude<keyof I, "$type">]: never; }>(_: I): MsgSetUriResponse;
};
/** Msg defines the oracle Msg service */
export interface Msg {
    /** Issue defines a method for issuing a new fan token */
    Issue(request: MsgIssue): Promise<MsgIssueResponse>;
    /** Mint defines a method for minting some fan tokens */
    Mint(request: MsgMint): Promise<MsgMintResponse>;
    /** Burn defines a method for burning some fan tokens */
    Burn(request: MsgBurn): Promise<MsgBurnResponse>;
    /** DisableMint defines a method for disable the mint function */
    DisableMint(request: MsgDisableMint): Promise<MsgDisableMintResponse>;
    SetMinter(request: MsgSetMinter): Promise<MsgSetMinterResponse>;
    SetAuthority(request: MsgSetAuthority): Promise<MsgSetAuthorityResponse>;
    SetUri(request: MsgSetUri): Promise<MsgSetUriResponse>;
}
export declare class MsgClientImpl implements Msg {
    private readonly rpc;
    constructor(rpc: Rpc);
    Issue(request: MsgIssue): Promise<MsgIssueResponse>;
    Mint(request: MsgMint): Promise<MsgMintResponse>;
    Burn(request: MsgBurn): Promise<MsgBurnResponse>;
    DisableMint(request: MsgDisableMint): Promise<MsgDisableMintResponse>;
    SetMinter(request: MsgSetMinter): Promise<MsgSetMinterResponse>;
    SetAuthority(request: MsgSetAuthority): Promise<MsgSetAuthorityResponse>;
    SetUri(request: MsgSetUri): Promise<MsgSetUriResponse>;
}
interface Rpc {
    request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
}
declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
export declare type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
    [K in Exclude<keyof T, '$type'>]?: DeepPartial<T[K]>;
} : Partial<T>;
declare type KeysOfUnion<T> = T extends T ? keyof T : never;
export declare type Exact<P, I extends P> = P extends Builtin ? P : P & {
    [K in keyof P]: Exact<P[K], I[K]>;
} & {
    [K in Exclude<keyof I, KeysOfUnion<P> | '$type'>]: never;
};
export {};