import _m0 from "protobufjs/minimal";
import { AccountID, Key, TokenFreezeStatus, TokenID, TokenKycStatus, TokenPauseStatus, TokenSupplyType, TokenType } from "./basic_types";
import { CustomFee } from "./custom_fees";
import { Duration } from "./duration";
import { QueryHeader } from "./query_header";
import { ResponseHeader } from "./response_header";
import { Timestamp } from "./timestamp";
export declare const protobufPackage = "proto";
/** Gets information about Token instance */
export interface TokenGetInfoQuery {
    /**
     * Standard info sent from client to node, including the signed payment, and what kind of
     * response is requested (cost, state proof, both, or neither)
     */
    header: QueryHeader | undefined;
    /**
     * The token for which information is requested. If invalid token is provided, INVALID_TOKEN_ID
     * response is returned.
     */
    token: TokenID | undefined;
}
/** The metadata about a Token instance */
export interface TokenInfo {
    /** ID of the token instance */
    tokenId: TokenID | undefined;
    /** The name of the token. It is a string of ASCII only characters */
    name: string;
    /** The symbol of the token. It is a UTF-8 capitalized alphabetical string */
    symbol: string;
    /**
     * The number of decimal places a token is divisible by. Always 0 for tokens of type
     * NON_FUNGIBLE_UNIQUE
     */
    decimals: number;
    /**
     * For tokens of type FUNGIBLE_COMMON - the total supply of tokens that are currently in
     * circulation. For tokens of type NON_FUNGIBLE_UNIQUE - the number of NFTs created of this
     * token instance
     */
    totalSupply: number;
    /** The ID of the account which is set as Treasury */
    treasury: AccountID | undefined;
    /**
     * The key which can perform update/delete operations on the token. If empty, the token can be
     * perceived as immutable (not being able to be updated/deleted)
     */
    adminKey: Key | undefined;
    /**
     * The key which can grant or revoke KYC of an account for the token's transactions. If empty,
     * KYC is not required, and KYC grant or revoke operations are not possible.
     */
    kycKey: Key | undefined;
    /**
     * The key which can freeze or unfreeze an account for token transactions. If empty, freezing is
     * not possible
     */
    freezeKey: Key | undefined;
    /** The key which can wipe token balance of an account. If empty, wipe is not possible */
    wipeKey: Key | undefined;
    /**
     * The key which can change the supply of a token. The key is used to sign Token Mint/Burn
     * operations
     */
    supplyKey: Key | undefined;
    /**
     * The default Freeze status (not applicable, frozen or unfrozen) of Hedera accounts relative to
     * this token. FreezeNotApplicable is returned if Token Freeze Key is empty. Frozen is returned
     * if Token Freeze Key is set and defaultFreeze is set to true. Unfrozen is returned if Token
     * Freeze Key is set and defaultFreeze is set to false
     */
    defaultFreezeStatus: TokenFreezeStatus;
    /**
     * The default KYC status (KycNotApplicable or Revoked) of Hedera accounts relative to this
     * token. KycNotApplicable is returned if KYC key is not set, otherwise Revoked
     */
    defaultKycStatus: TokenKycStatus;
    /** Specifies whether the token was deleted or not */
    deleted: boolean;
    /**
     * An account which will be automatically charged to renew the token's expiration, at
     * autoRenewPeriod interval
     */
    autoRenewAccount: AccountID | undefined;
    /** The interval at which the auto-renew account will be charged to extend the token's expiry */
    autoRenewPeriod: Duration | undefined;
    /** The epoch second at which the token will expire */
    expiry: Timestamp | undefined;
    /** The memo associated with the token */
    memo: string;
    /** The token type */
    tokenType: TokenType;
    /** The token supply type */
    supplyType: TokenSupplyType;
    /**
     * For tokens of type FUNGIBLE_COMMON - The Maximum number of fungible tokens that can be in
     * circulation. For tokens of type NON_FUNGIBLE_UNIQUE - the maximum number of NFTs (serial
     * numbers) that can be in circulation
     */
    maxSupply: number;
    /**
     * The key which can change the custom fee schedule of the token; if not set, the fee schedule
     * is immutable
     */
    feeScheduleKey: Key | undefined;
    /** The custom fees to be assessed during a CryptoTransfer that transfers units of this token */
    customFees: CustomFee[];
    /** The Key which can pause and unpause the Token. */
    pauseKey: Key | undefined;
    /** Specifies whether the token is paused or not. PauseNotApplicable is returned if pauseKey is not set. */
    pauseStatus: TokenPauseStatus;
    /** The ledger ID the response was returned from; please see <a href="https://github.com/hashgraph/hedera-improvement-proposal/blob/master/HIP/hip-198.md">HIP-198</a> for the network-specific IDs. */
    ledgerId: Uint8Array;
}
/** Response when the client sends the node TokenGetInfoQuery */
export interface TokenGetInfoResponse {
    /**
     * Standard response from node to client, including the requested fields: cost, or state proof,
     * or both, or neither
     */
    header: ResponseHeader | undefined;
    /** The information requested about this token instance */
    tokenInfo: TokenInfo | undefined;
}
export declare const TokenGetInfoQuery: {
    encode(message: TokenGetInfoQuery, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): TokenGetInfoQuery;
    fromJSON(object: any): TokenGetInfoQuery;
    toJSON(message: TokenGetInfoQuery): unknown;
    create(base?: DeepPartial<TokenGetInfoQuery>): TokenGetInfoQuery;
    fromPartial(object: DeepPartial<TokenGetInfoQuery>): TokenGetInfoQuery;
};
export declare const TokenInfo: {
    encode(message: TokenInfo, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): TokenInfo;
    fromJSON(object: any): TokenInfo;
    toJSON(message: TokenInfo): unknown;
    create(base?: DeepPartial<TokenInfo>): TokenInfo;
    fromPartial(object: DeepPartial<TokenInfo>): TokenInfo;
};
export declare const TokenGetInfoResponse: {
    encode(message: TokenGetInfoResponse, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): TokenGetInfoResponse;
    fromJSON(object: any): TokenGetInfoResponse;
    toJSON(message: TokenGetInfoResponse): unknown;
    create(base?: DeepPartial<TokenGetInfoResponse>): TokenGetInfoResponse;
    fromPartial(object: DeepPartial<TokenGetInfoResponse>): TokenGetInfoResponse;
};
type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
export 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 {
    $case: string;
} ? {
    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
} & {
    $case: T["$case"];
} : T extends {} ? {
    [K in keyof T]?: DeepPartial<T[K]>;
} : Partial<T>;
export {};
//# sourceMappingURL=token_get_info.d.ts.map