import _m0 from "protobufjs/minimal";
import { AccountID, Key, TokenSupplyType, TokenType } from "./basic_types";
import { CustomFee } from "./custom_fees";
import { Duration } from "./duration";
import { Timestamp } from "./timestamp";
export declare const protobufPackage = "proto";
/**
 * Create a new token. After the token is created, the Token ID for it is in the receipt.
 * The specified Treasury Account is receiving the initial supply of tokens as-well as the tokens
 * from the Token Mint operation once executed. The balance of the treasury account is decreased
 * when the Token Burn operation is executed.
 *
 * The <tt>initialSupply</tt> is the initial supply of the smallest parts of a token (like a
 * tinybar, not an hbar). These are the smallest units of the token which may be transferred.
 *
 * The supply can change over time. If the total supply at some moment is <i>S</i> parts of tokens,
 * and the token is using <i>D</i> decimals, then <i>S</i> must be less than or equal to
 * 2<sup>63</sup>-1, which is 9,223,372,036,854,775,807. The number of whole tokens (not parts) will
 * be <i>S / 10<sup>D</sup></i>.
 *
 * If decimals is 8 or 11, then the number of whole tokens can be at most a few billions or
 * millions, respectively. For example, it could match Bitcoin (21 million whole tokens with 8
 * decimals) or hbars (50 billion whole tokens with 8 decimals). It could even match Bitcoin with
 * milli-satoshis (21 million whole tokens with 11 decimals).
 *
 * Note that a created token is <i>immutable</i> if the <tt>adminKey</tt> is omitted. No property of
 * an immutable token can ever change, with the sole exception of its expiry. Anyone can pay to
 * extend the expiry time of an immutable token.
 *
 * A token can be either <i>FUNGIBLE_COMMON</i> or <i>NON_FUNGIBLE_UNIQUE</i>, based on its
 * <i>TokenType</i>. If it has been omitted, <i>FUNGIBLE_COMMON</i> type is used.
 *
 * A token can have either <i>INFINITE</i> or <i>FINITE</i> supply type, based on its
 * <i>TokenType</i>. If it has been omitted, <i>INFINITE</i> type is used.
 *
 * If a <i>FUNGIBLE</i> TokenType is used, <i>initialSupply</i> should explicitly be set to a
 * non-negative. If not, the transaction will resolve to INVALID_TOKEN_INITIAL_SUPPLY.
 *
 * If a <i>NON_FUNGIBLE_UNIQUE</i> TokenType is used, <i>initialSupply</i> should explicitly be set
 * to 0. If not, the transaction will resolve to INVALID_TOKEN_INITIAL_SUPPLY.
 *
 * If an <i>INFINITE</i> TokenSupplyType is used, <i>maxSupply</i> should explicitly be set to 0. If
 * it is not 0, the transaction will resolve to INVALID_TOKEN_MAX_SUPPLY.
 *
 * If a <i>FINITE</i> TokenSupplyType is used, <i>maxSupply</i> should be explicitly set to a
 * non-negative value. If it is not, the transaction will resolve to INVALID_TOKEN_MAX_SUPPLY.
 */
export interface TokenCreateTransactionBody {
    /**
     * The publicly visible name of the token. The token name is specified as a Unicode string.
     * Its UTF-8 encoding cannot exceed 100 bytes, and cannot contain the 0 byte (NUL).
     */
    name: string;
    /**
     * The publicly visible token symbol. The token symbol is specified as a Unicode string.
     * Its UTF-8 encoding cannot exceed 100 bytes, and cannot contain the 0 byte (NUL).
     */
    symbol: string;
    /**
     * For tokens of type FUNGIBLE_COMMON - the number of decimal places a
     * token is divisible by. For tokens of type NON_FUNGIBLE_UNIQUE - value
     * must be 0
     */
    decimals: number;
    /**
     * Specifies the initial supply of tokens to be put in circulation. The
     * initial supply is sent to the Treasury Account. The supply is in the
     * lowest denomination possible. In the case for NON_FUNGIBLE_UNIQUE Type
     * the value must be 0
     */
    initialSupply: number;
    /**
     * The account which will act as a treasury for the token. This account
     * will receive the specified initial supply or the newly minted NFTs in
     * the case for NON_FUNGIBLE_UNIQUE Type
     */
    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 sign to freeze or unfreeze an account for token transactions. If empty,
     * freezing is not possible
     */
    freezeKey: Key | undefined;
    /** The key which can wipe the 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 (frozen or unfrozen) of Hedera accounts relative to this token. If
     * true, an account must be unfrozen before it can receive the token
     */
    freezeDefault: boolean;
    /**
     * The epoch second at which the token should expire; if an auto-renew account and period are
     * specified, this is coerced to the current epoch second plus the autoRenewPeriod
     */
    expiry: Timestamp | undefined;
    /**
     * 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 memo associated with the token (UTF-8 encoding max 100 bytes) */
    memo: string;
    /** IWA compatibility. Specifies the token type. Defaults to FUNGIBLE_COMMON */
    tokenType: TokenType;
    /** IWA compatibility. Specified the token supply type. Defaults to INFINITE */
    supplyType: TokenSupplyType;
    /**
     * IWA Compatibility. Depends on TokenSupplyType. For tokens of type FUNGIBLE_COMMON - the
     * maximum number of tokens that can be in circulation. For tokens of type NON_FUNGIBLE_UNIQUE -
     * the maximum number of NFTs (serial numbers) that can be minted. This field can never be
     * changed!
     */
    maxSupply: number;
    /**
     * The key which can change the token's custom fee schedule; must sign a TokenFeeScheduleUpdate
     * transaction
     */
    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.
     * If Empty the token pause status defaults to PauseNotApplicable, otherwise Unpaused.
     */
    pauseKey: Key | undefined;
}
export declare const TokenCreateTransactionBody: {
    encode(message: TokenCreateTransactionBody, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): TokenCreateTransactionBody;
    fromJSON(object: any): TokenCreateTransactionBody;
    toJSON(message: TokenCreateTransactionBody): unknown;
    create(base?: DeepPartial<TokenCreateTransactionBody>): TokenCreateTransactionBody;
    fromPartial(object: DeepPartial<TokenCreateTransactionBody>): TokenCreateTransactionBody;
};
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_create.d.ts.map