import _m0 from "protobufjs/minimal";
import { PageRequest, PageResponse } from "../cosmos/base/query/v1beta1/pagination";
import { Info } from "./info";
import { Item } from "./item";
import { Params } from "./params";
export declare const protobufPackage = "rarifyprotocol.rarimocore.tokenmanager";
/** QueryParamsRequest is request type for the Query/Params RPC method. */
export interface QueryParamsRequest {
}
/** QueryParamsResponse is response type for the Query/Params RPC method. */
export interface QueryParamsResponse {
    /** params holds all the parameters of this module. */
    params: Params | undefined;
}
export interface QueryGetItemRequest {
    tokenAddress: string;
    tokenId: string;
    chain: string;
}
export interface QueryGetItemResponse {
    item: Item | undefined;
}
export interface QueryGetItemByChainRequest {
    infoIndex: string;
    chain: string;
}
export interface QueryGetItemByChainResponse {
    item: Item | undefined;
}
export interface QueryAllItemRequest {
    pagination: PageRequest | undefined;
}
export interface QueryAllItemResponse {
    item: Item[];
    pagination: PageResponse | undefined;
}
export interface QueryGetInfoRequest {
    index: string;
}
export interface QueryGetInfoResponse {
    info: Info | undefined;
}
export interface QueryAllInfoRequest {
    pagination: PageRequest | undefined;
}
export interface QueryAllInfoResponse {
    info: Info[];
    pagination: PageResponse | undefined;
}
export declare const QueryParamsRequest: {
    encode(_: QueryParamsRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryParamsRequest;
    fromJSON(_: any): QueryParamsRequest;
    toJSON(_: QueryParamsRequest): unknown;
    fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): QueryParamsRequest;
};
export declare const QueryParamsResponse: {
    encode(message: QueryParamsResponse, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryParamsResponse;
    fromJSON(object: any): QueryParamsResponse;
    toJSON(message: QueryParamsResponse): unknown;
    fromPartial<I extends {
        params?: {
            networks?: {
                [x: string]: {
                    contract?: string;
                    types?: {
                        [x: string]: number;
                    };
                    type?: import("./params").NetworkType;
                };
            };
        };
    } & {
        params?: {
            networks?: {
                [x: string]: {
                    contract?: string;
                    types?: {
                        [x: string]: number;
                    };
                    type?: import("./params").NetworkType;
                };
            };
        } & {
            networks?: {
                [x: string]: {
                    contract?: string;
                    types?: {
                        [x: string]: number;
                    };
                    type?: import("./params").NetworkType;
                };
            } & {
                [x: string]: {
                    contract?: string;
                    types?: {
                        [x: string]: number;
                    };
                    type?: import("./params").NetworkType;
                } & {
                    contract?: string;
                    types?: {
                        [x: string]: number;
                    } & {
                        [x: string]: number;
                    } & { [K in Exclude<keyof I["params"]["networks"][string]["types"], string | number>]: never; };
                    type?: import("./params").NetworkType;
                } & { [K_1 in Exclude<keyof I["params"]["networks"][string], keyof import("./params").ChainParams>]: never; };
            } & { [K_2 in Exclude<keyof I["params"]["networks"], string | number>]: never; };
        } & { [K_3 in Exclude<keyof I["params"], "networks">]: never; };
    } & { [K_4 in Exclude<keyof I, "params">]: never; }>(object: I): QueryParamsResponse;
};
export declare const QueryGetItemRequest: {
    encode(message: QueryGetItemRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryGetItemRequest;
    fromJSON(object: any): QueryGetItemRequest;
    toJSON(message: QueryGetItemRequest): unknown;
    fromPartial<I extends {
        tokenAddress?: string;
        tokenId?: string;
        chain?: string;
    } & {
        tokenAddress?: string;
        tokenId?: string;
        chain?: string;
    } & { [K in Exclude<keyof I, keyof QueryGetItemRequest>]: never; }>(object: I): QueryGetItemRequest;
};
export declare const QueryGetItemResponse: {
    encode(message: QueryGetItemResponse, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryGetItemResponse;
    fromJSON(object: any): QueryGetItemResponse;
    toJSON(message: QueryGetItemResponse): unknown;
    fromPartial<I extends {
        item?: {
            tokenAddress?: string;
            tokenId?: string;
            chain?: string;
            index?: string;
            name?: string;
            symbol?: string;
            uri?: string;
            decimals?: number;
            seed?: string;
            imageUri?: string;
            imageHash?: string;
            tokenType?: import("./item").type;
            wrapped?: boolean;
        };
    } & {
        item?: {
            tokenAddress?: string;
            tokenId?: string;
            chain?: string;
            index?: string;
            name?: string;
            symbol?: string;
            uri?: string;
            decimals?: number;
            seed?: string;
            imageUri?: string;
            imageHash?: string;
            tokenType?: import("./item").type;
            wrapped?: boolean;
        } & {
            tokenAddress?: string;
            tokenId?: string;
            chain?: string;
            index?: string;
            name?: string;
            symbol?: string;
            uri?: string;
            decimals?: number;
            seed?: string;
            imageUri?: string;
            imageHash?: string;
            tokenType?: import("./item").type;
            wrapped?: boolean;
        } & { [K in Exclude<keyof I["item"], keyof Item>]: never; };
    } & { [K_1 in Exclude<keyof I, "item">]: never; }>(object: I): QueryGetItemResponse;
};
export declare const QueryGetItemByChainRequest: {
    encode(message: QueryGetItemByChainRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryGetItemByChainRequest;
    fromJSON(object: any): QueryGetItemByChainRequest;
    toJSON(message: QueryGetItemByChainRequest): unknown;
    fromPartial<I extends {
        infoIndex?: string;
        chain?: string;
    } & {
        infoIndex?: string;
        chain?: string;
    } & { [K in Exclude<keyof I, keyof QueryGetItemByChainRequest>]: never; }>(object: I): QueryGetItemByChainRequest;
};
export declare const QueryGetItemByChainResponse: {
    encode(message: QueryGetItemByChainResponse, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryGetItemByChainResponse;
    fromJSON(object: any): QueryGetItemByChainResponse;
    toJSON(message: QueryGetItemByChainResponse): unknown;
    fromPartial<I extends {
        item?: {
            tokenAddress?: string;
            tokenId?: string;
            chain?: string;
            index?: string;
            name?: string;
            symbol?: string;
            uri?: string;
            decimals?: number;
            seed?: string;
            imageUri?: string;
            imageHash?: string;
            tokenType?: import("./item").type;
            wrapped?: boolean;
        };
    } & {
        item?: {
            tokenAddress?: string;
            tokenId?: string;
            chain?: string;
            index?: string;
            name?: string;
            symbol?: string;
            uri?: string;
            decimals?: number;
            seed?: string;
            imageUri?: string;
            imageHash?: string;
            tokenType?: import("./item").type;
            wrapped?: boolean;
        } & {
            tokenAddress?: string;
            tokenId?: string;
            chain?: string;
            index?: string;
            name?: string;
            symbol?: string;
            uri?: string;
            decimals?: number;
            seed?: string;
            imageUri?: string;
            imageHash?: string;
            tokenType?: import("./item").type;
            wrapped?: boolean;
        } & { [K in Exclude<keyof I["item"], keyof Item>]: never; };
    } & { [K_1 in Exclude<keyof I, "item">]: never; }>(object: I): QueryGetItemByChainResponse;
};
export declare const QueryAllItemRequest: {
    encode(message: QueryAllItemRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryAllItemRequest;
    fromJSON(object: any): QueryAllItemRequest;
    toJSON(message: QueryAllItemRequest): unknown;
    fromPartial<I extends {
        pagination?: {
            key?: Uint8Array;
            offset?: number;
            limit?: number;
            countTotal?: boolean;
        };
    } & {
        pagination?: {
            key?: Uint8Array;
            offset?: number;
            limit?: number;
            countTotal?: boolean;
        } & {
            key?: Uint8Array;
            offset?: number;
            limit?: number;
            countTotal?: boolean;
        } & { [K in Exclude<keyof I["pagination"], keyof PageRequest>]: never; };
    } & { [K_1 in Exclude<keyof I, "pagination">]: never; }>(object: I): QueryAllItemRequest;
};
export declare const QueryAllItemResponse: {
    encode(message: QueryAllItemResponse, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryAllItemResponse;
    fromJSON(object: any): QueryAllItemResponse;
    toJSON(message: QueryAllItemResponse): unknown;
    fromPartial<I extends {
        item?: {
            tokenAddress?: string;
            tokenId?: string;
            chain?: string;
            index?: string;
            name?: string;
            symbol?: string;
            uri?: string;
            decimals?: number;
            seed?: string;
            imageUri?: string;
            imageHash?: string;
            tokenType?: import("./item").type;
            wrapped?: boolean;
        }[];
        pagination?: {
            nextKey?: Uint8Array;
            total?: number;
        };
    } & {
        item?: {
            tokenAddress?: string;
            tokenId?: string;
            chain?: string;
            index?: string;
            name?: string;
            symbol?: string;
            uri?: string;
            decimals?: number;
            seed?: string;
            imageUri?: string;
            imageHash?: string;
            tokenType?: import("./item").type;
            wrapped?: boolean;
        }[] & ({
            tokenAddress?: string;
            tokenId?: string;
            chain?: string;
            index?: string;
            name?: string;
            symbol?: string;
            uri?: string;
            decimals?: number;
            seed?: string;
            imageUri?: string;
            imageHash?: string;
            tokenType?: import("./item").type;
            wrapped?: boolean;
        } & {
            tokenAddress?: string;
            tokenId?: string;
            chain?: string;
            index?: string;
            name?: string;
            symbol?: string;
            uri?: string;
            decimals?: number;
            seed?: string;
            imageUri?: string;
            imageHash?: string;
            tokenType?: import("./item").type;
            wrapped?: boolean;
        } & { [K in Exclude<keyof I["item"][number], keyof Item>]: never; })[] & { [K_1 in Exclude<keyof I["item"], keyof {
            tokenAddress?: string;
            tokenId?: string;
            chain?: string;
            index?: string;
            name?: string;
            symbol?: string;
            uri?: string;
            decimals?: number;
            seed?: string;
            imageUri?: string;
            imageHash?: string;
            tokenType?: import("./item").type;
            wrapped?: boolean;
        }[]>]: never; };
        pagination?: {
            nextKey?: Uint8Array;
            total?: number;
        } & {
            nextKey?: Uint8Array;
            total?: number;
        } & { [K_2 in Exclude<keyof I["pagination"], keyof PageResponse>]: never; };
    } & { [K_3 in Exclude<keyof I, keyof QueryAllItemResponse>]: never; }>(object: I): QueryAllItemResponse;
};
export declare const QueryGetInfoRequest: {
    encode(message: QueryGetInfoRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryGetInfoRequest;
    fromJSON(object: any): QueryGetInfoRequest;
    toJSON(message: QueryGetInfoRequest): unknown;
    fromPartial<I extends {
        index?: string;
    } & {
        index?: string;
    } & { [K in Exclude<keyof I, "index">]: never; }>(object: I): QueryGetInfoRequest;
};
export declare const QueryGetInfoResponse: {
    encode(message: QueryGetInfoResponse, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryGetInfoResponse;
    fromJSON(object: any): QueryGetInfoResponse;
    toJSON(message: QueryGetInfoResponse): unknown;
    fromPartial<I extends {
        info?: {
            index?: string;
            chains?: {
                [x: string]: {
                    tokenAddress?: string;
                    tokenId?: string;
                };
            };
            creator?: string;
        };
    } & {
        info?: {
            index?: string;
            chains?: {
                [x: string]: {
                    tokenAddress?: string;
                    tokenId?: string;
                };
            };
            creator?: string;
        } & {
            index?: string;
            chains?: {
                [x: string]: {
                    tokenAddress?: string;
                    tokenId?: string;
                };
            } & {
                [x: string]: {
                    tokenAddress?: string;
                    tokenId?: string;
                } & {
                    tokenAddress?: string;
                    tokenId?: string;
                } & { [K in Exclude<keyof I["info"]["chains"][string], keyof import("./info").ChainInfo>]: never; };
            } & { [K_1 in Exclude<keyof I["info"]["chains"], string | number>]: never; };
            creator?: string;
        } & { [K_2 in Exclude<keyof I["info"], keyof Info>]: never; };
    } & { [K_3 in Exclude<keyof I, "info">]: never; }>(object: I): QueryGetInfoResponse;
};
export declare const QueryAllInfoRequest: {
    encode(message: QueryAllInfoRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryAllInfoRequest;
    fromJSON(object: any): QueryAllInfoRequest;
    toJSON(message: QueryAllInfoRequest): unknown;
    fromPartial<I extends {
        pagination?: {
            key?: Uint8Array;
            offset?: number;
            limit?: number;
            countTotal?: boolean;
        };
    } & {
        pagination?: {
            key?: Uint8Array;
            offset?: number;
            limit?: number;
            countTotal?: boolean;
        } & {
            key?: Uint8Array;
            offset?: number;
            limit?: number;
            countTotal?: boolean;
        } & { [K in Exclude<keyof I["pagination"], keyof PageRequest>]: never; };
    } & { [K_1 in Exclude<keyof I, "pagination">]: never; }>(object: I): QueryAllInfoRequest;
};
export declare const QueryAllInfoResponse: {
    encode(message: QueryAllInfoResponse, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryAllInfoResponse;
    fromJSON(object: any): QueryAllInfoResponse;
    toJSON(message: QueryAllInfoResponse): unknown;
    fromPartial<I extends {
        info?: {
            index?: string;
            chains?: {
                [x: string]: {
                    tokenAddress?: string;
                    tokenId?: string;
                };
            };
            creator?: string;
        }[];
        pagination?: {
            nextKey?: Uint8Array;
            total?: number;
        };
    } & {
        info?: {
            index?: string;
            chains?: {
                [x: string]: {
                    tokenAddress?: string;
                    tokenId?: string;
                };
            };
            creator?: string;
        }[] & ({
            index?: string;
            chains?: {
                [x: string]: {
                    tokenAddress?: string;
                    tokenId?: string;
                };
            };
            creator?: string;
        } & {
            index?: string;
            chains?: {
                [x: string]: {
                    tokenAddress?: string;
                    tokenId?: string;
                };
            } & {
                [x: string]: {
                    tokenAddress?: string;
                    tokenId?: string;
                } & {
                    tokenAddress?: string;
                    tokenId?: string;
                } & { [K in Exclude<keyof I["info"][number]["chains"][string], keyof import("./info").ChainInfo>]: never; };
            } & { [K_1 in Exclude<keyof I["info"][number]["chains"], string | number>]: never; };
            creator?: string;
        } & { [K_2 in Exclude<keyof I["info"][number], keyof Info>]: never; })[] & { [K_3 in Exclude<keyof I["info"], keyof {
            index?: string;
            chains?: {
                [x: string]: {
                    tokenAddress?: string;
                    tokenId?: string;
                };
            };
            creator?: string;
        }[]>]: never; };
        pagination?: {
            nextKey?: Uint8Array;
            total?: number;
        } & {
            nextKey?: Uint8Array;
            total?: number;
        } & { [K_4 in Exclude<keyof I["pagination"], keyof PageResponse>]: never; };
    } & { [K_5 in Exclude<keyof I, keyof QueryAllInfoResponse>]: never; }>(object: I): QueryAllInfoResponse;
};
/** Query defines the gRPC querier service. */
export interface Query {
    /** Parameters queries the parameters of the module. */
    Params(request: QueryParamsRequest): Promise<QueryParamsResponse>;
    /** Queries a Item by index. */
    Item(request: QueryGetItemRequest): Promise<QueryGetItemResponse>;
    /** Queries a Item by chain. */
    ItemByChain(request: QueryGetItemByChainRequest): Promise<QueryGetItemByChainResponse>;
    /** Queries a list of Item items. */
    ItemAll(request: QueryAllItemRequest): Promise<QueryAllItemResponse>;
    /** Queries a Info by index. */
    Info(request: QueryGetInfoRequest): Promise<QueryGetInfoResponse>;
    /** Queries a list of Info items. */
    InfoAll(request: QueryAllInfoRequest): Promise<QueryAllInfoResponse>;
}
export declare class QueryClientImpl implements Query {
    private readonly rpc;
    constructor(rpc: Rpc);
    Params(request: QueryParamsRequest): Promise<QueryParamsResponse>;
    Item(request: QueryGetItemRequest): Promise<QueryGetItemResponse>;
    ItemByChain(request: QueryGetItemByChainRequest): Promise<QueryGetItemByChainResponse>;
    ItemAll(request: QueryAllItemRequest): Promise<QueryAllItemResponse>;
    Info(request: QueryGetInfoRequest): Promise<QueryGetInfoResponse>;
    InfoAll(request: QueryAllInfoRequest): Promise<QueryAllInfoResponse>;
}
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 Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
    [K in keyof T]?: 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>>]: never;
};
export {};
