import type { AptosConfig } from "../api/aptosConfig.js";
import { InputSubmitTransactionData } from "../transactions/index.js";
import { Network } from "../utils/apiEndpoints.js";
import { OrderBy, TokenStandard } from "./indexer.js";
/**
 * Different MIME types used for data interchange in transactions and responses.
 */
export declare enum MimeType {
    /**
     * JSON representation, used for transaction submission and accept type JSON output
     */
    JSON = "application/json",
    /**
     * BCS representation, used for accept type BCS output
     */
    BCS = "application/x-bcs",
    /**
     * BCS representation, used for transaction submission in BCS input
     */
    BCS_SIGNED_TRANSACTION = "application/x.aptos.signed_transaction+bcs",
    BCS_VIEW_FUNCTION = "application/x.aptos.view_function+bcs"
}
/**
 * Hexadecimal data input for functions, supporting both string and Uint8Array formats.
 */
export type HexInput = string | Uint8Array;
/**
 * Variants of type tags used in the system, encompassing various data types and structures.
 * {@link https://github.com/aptos-labs/aptos-core/blob/main/third_party/move/move-core/types/src/language_storage.rs#L27}
 */
export declare enum TypeTagVariants {
    Bool = 0,
    U8 = 1,
    U64 = 2,
    U128 = 3,
    Address = 4,
    Signer = 5,
    Vector = 6,
    Struct = 7,
    U16 = 8,
    U32 = 9,
    U256 = 10,
    I8 = 11,
    I16 = 12,
    I32 = 13,
    I64 = 14,
    I128 = 15,
    I256 = 16,
    Reference = 254,// This is specifically a placeholder and does not represent a real type
    Generic = 255
}
/**
 * Variants of script transaction arguments used in Rust, encompassing various data types for transaction processing.
 * {@link https://github.com/aptos-labs/aptos-core/blob/main/third_party/move/move-core/types/src/transaction_argument.rs#L11}
 */
export declare enum ScriptTransactionArgumentVariants {
    U8 = 0,
    U64 = 1,
    U128 = 2,
    Address = 3,
    U8Vector = 4,
    Bool = 5,
    U16 = 6,
    U32 = 7,
    U256 = 8,
    Serialized = 9,
    I8 = 10,
    I16 = 11,
    I32 = 12,
    I64 = 13,
    I128 = 14,
    I256 = 15
}
/**
 * The payload for various transaction types in the system.
 * {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/mod.rs#L478}
 */
export declare enum TransactionPayloadVariants {
    Script = 0,
    EntryFunction = 2,
    Multisig = 3,
    Payload = 4,
    EncryptedPayload = 5
}
/**
 * Variants for the inner payload of a multisig account transaction.
 * {@link https://github.com/aptos-labs/aptos-core/blob/main/aptos-move/framework/aptos-framework/sources/multisig_account.move}
 */
export declare enum MultiSigTransactionPayloadVariants {
    EntryFunction = 0,
    Script = 1
}
/**
 * The inner payload type to support orderless transactions and all future transaction types.
 * {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/mod.rs#L478}
 */
export declare enum TransactionInnerPayloadVariants {
    V1 = 0
}
/**
 * Executable types for transactions, which can be either a script or an entry function.
 *
 * Empty is reserved for Multisig voting transactions, which do not have an executable payload.
 * {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/mod.rs#L685}
 */
export declare enum TransactionExecutableVariants {
    Script = 0,
    EntryFunction = 1,
    Empty = 2,
    Encrypted = 3
}
/**
 * Variants of transaction extra configurations, which can include additional settings or parameters.
 * {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/mod.rs#L737}
 */
export declare enum TransactionExtraConfigVariants {
    V1 = 0
}
/**
 * Variants of transactions used in the system.
 * {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/mod.rs#L440}
 */
export declare enum TransactionVariants {
    MultiAgentTransaction = 0,
    FeePayerTransaction = 1
}
/**
 * Variants of transaction authenticators used in the system.
 * {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/authenticator.rs#L44}
 */
export declare enum TransactionAuthenticatorVariant {
    Ed25519 = 0,
    MultiEd25519 = 1,
    MultiAgent = 2,
    FeePayer = 3,
    SingleSender = 4
}
/**
 * Variants of account authenticators used in transactions.
 * {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/authenticator.rs#L414}
 */
export declare enum AccountAuthenticatorVariant {
    Ed25519 = 0,
    MultiEd25519 = 1,
    SingleKey = 2,
    MultiKey = 3,
    NoAccountAuthenticator = 4,
    Abstraction = 5
}
/**
 * Variants of private keys that can comply with the AIP-80 standard.
 * {@link https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md}
 */
export declare enum PrivateKeyVariants {
    Ed25519 = "ed25519",
    Secp256k1 = "secp256k1",
    Secp256r1 = "secp256r1"
}
/**
 * Variants of public keys used in cryptographic operations.
 */
export declare enum AnyPublicKeyVariant {
    Ed25519 = 0,
    Secp256k1 = 1,
    Secp256r1 = 2,
    Keyless = 3,
    FederatedKeyless = 4,
    /**
     * Post-quantum signature scheme (SLH-DSA-SHA2-128s).
     * Note: Full implementation not yet available in this SDK.
     */
    SlhDsaSha2_128s = 5
}
export declare function anyPublicKeyVariantToString(variant: AnyPublicKeyVariant): string;
/**
 * Variants of signature types used for cryptographic operations.
 */
export declare enum AnySignatureVariant {
    Ed25519 = 0,
    Secp256k1 = 1,
    WebAuthn = 2,
    Keyless = 3,
    /**
     * Post-quantum signature scheme (SLH-DSA-SHA2-128s).
     * Note: Full implementation not yet available in this SDK.
     */
    SlhDsaSha2_128s = 4
}
/**
 * Variants of ephemeral public keys used in cryptographic operations.
 */
export declare enum EphemeralPublicKeyVariant {
    Ed25519 = 0
}
/**
 * Variants of ephemeral signatures used for secure communication.
 */
export declare enum EphemeralSignatureVariant {
    Ed25519 = 0
}
/**
 * Variants of ephemeral certificates used in secure transactions.
 */
export declare enum EphemeralCertificateVariant {
    ZkProof = 0
}
/**
 * Variants of zero-knowledge proofs used in cryptographic operations.
 */
export declare enum ZkpVariant {
    Groth16 = 0
}
/**
 * BCS types
 */
export type Uint8 = number;
/**
 * A 16-bit unsigned integer.
 */
export type Uint16 = number;
/**
 * A 32-bit unsigned integer.
 */
export type Uint32 = number;
/**
 * A 64-bit unsigned integer value.
 */
export type Uint64 = bigint;
/**
 * A 128-bit unsigned integer used for precise arithmetic operations.
 */
export type Uint128 = bigint;
/**
 * A 256-bit unsigned integer used for precise numerical calculations.
 */
export type Uint256 = bigint;
/**
 * A signed 8-bit integer.
 */
export type Int8 = number;
/**
 * A signed 16-bit integer.
 */
export type Int16 = number;
/**
 * A signed 32-bit integer.
 */
export type Int32 = number;
/**
 * A signed 64-bit integer.
 */
export type Int64 = bigint;
/**
 * A signed 128-bit integer.
 */
export type Int128 = bigint;
/**
 * A signed 256-bit integer.
 */
export type Int256 = bigint;
/**
 * A number or a bigint value.
 */
export type AnyNumber = number | bigint;
/**
 * Configuration options for initializing the SDK, allowing customization of its behavior and interaction with the Aptos network.
 */
export type AptosSettings = {
    readonly network?: Network;
    readonly fullnode?: string;
    readonly faucet?: string;
    readonly indexer?: string;
    readonly pepper?: string;
    readonly prover?: string;
    readonly clientConfig?: ClientConfig;
    readonly client?: Client;
    readonly fullnodeConfig?: FullNodeConfig;
    readonly indexerConfig?: IndexerConfig;
    readonly faucetConfig?: FaucetConfig;
    readonly transactionGenerationConfig?: TransactionGenerationConfig;
    readonly pluginSettings?: PluginSettings;
    /**
     * Whether reads of pruned history are retried against the archival endpoint the node advertises.
     * Defaults to `true`.
     */
    readonly archivalFallback?: boolean;
};
/**
 * Defines the parameters for paginating query results, including the starting position and maximum number of items to return.
 * @param offset Specifies the starting position of the query result. Default is 0.
 * @param limit Specifies the maximum number of items to return. Default is 25.
 */
export interface PaginationArgs {
    offset?: AnyNumber;
    limit?: number;
}
/**
 * Defines the parameters for paginating query results, including the starting position and maximum number of items to return.
 * @param cursor Specifies the starting position of the query result. Default is at the beginning if undefined.  This is not a number and must come from the API.
 * @param limit Specifies the maximum number of items to return. Default is 25.
 */
export interface CursorPaginationArgs {
    cursor?: string;
    limit?: number;
}
/**
 * Represents the arguments for specifying a token standard.
 *
 * @param tokenStandard - Optional standard of the token.
 */
export interface TokenStandardArg {
    tokenStandard?: TokenStandard;
}
export interface OrderByArg<T extends {}> {
    orderBy?: OrderBy<T>;
}
export interface WhereArg<T extends {}> {
    where?: T;
}
/**
 * QUERY TYPES
 */
/**
 * A configuration object for requests to the server, including API key, extra headers, and cookie handling options.
 *
 * Security Note: Consider implementing client-side rate limiting in your application to prevent
 * accidental API abuse. You can use libraries like 'bottleneck' or 'p-queue' to limit request rates.
 *
 * @example
 * ```typescript
 * import Bottleneck from 'bottleneck';
 *
 * // Create a limiter that allows 10 requests per second
 * const limiter = new Bottleneck({ minTime: 100, maxConcurrent: 5 });
 *
 * // Wrap your Aptos calls with the limiter
 * const result = await limiter.schedule(() => aptos.getAccountInfo({ accountAddress }));
 * ```
 */
export type ClientConfig = ClientHeadersType & {
    WITH_CREDENTIALS?: boolean;
    API_KEY?: string;
    http2?: boolean;
};
/**
 * A configuration object for a Fullnode, allowing for the inclusion of extra headers in requests.
 */
export type FullNodeConfig = ClientHeadersType;
/**
 * An Indexer configuration object for sending requests with additional headers.
 */
export type IndexerConfig = ClientHeadersType;
/**
 * A configuration object for a faucet, including optional authentication and headers for requests.
 */
export type FaucetConfig = ClientHeadersType & {
    AUTH_TOKEN?: string;
};
/**
 * A configuration object for default parameters for transaction generation.
 */
export type TransactionGenerationConfig = {
    defaultMaxGasAmount?: number;
    defaultTxnExpirySecFromNow?: number;
};
/**
 * General type definition for client headers.
 */
export type ClientHeadersType = {
    HEADERS?: Record<string, string | number | boolean>;
};
/**
 * Config for plugins. This can be used to override certain client behavior.
 */
export type PluginConfig = {
    /**
     * If given, this will be used for submitting transactions instead of the default
     * implementation (which submits transactions directly via a node).
     */
    TRANSACTION_SUBMITTER?: TransactionSubmitter;
    /**
     * If true, we won't use the TRANSACTION_SUBMITTER if set.
     */
    IGNORE_TRANSACTION_SUBMITTER?: boolean;
};
export type PluginSettings = Omit<PluginConfig, "IGNORE_TRANSACTION_SUBMITTER">;
/**
 * You can implement this interface and set it in {@link PluginSettings} when building a
 * client to override the default transaction submission behavior. This is useful if
 * you'd like to submit transactions via a gas station for example.
 *
 * @example
 * ```typescript
 * class MyGasStationClient implements TransactionSubmitter {
 *   async submitTransaction(
 *     args: { aptosConfig: AptosConfig } & InputSubmitTransactionData,
 *   ): Promise<PendingTransactionResponse> {
 *     // TODO: Implement the logic to submit the transaction to the gas station
 *   }
 * }
 *
 * const network = Network.MAINNET;
 * const myGasStationClient = new MyGasStationClient(network);
 * const config = new AptosConfig({
 *   network,
 *   pluginConfig: {
 *     transactionSubmitter: myGasStationClient,
 *   },
 * });
 * const aptos = new Aptos(config);
 * ```
 */
export interface TransactionSubmitter {
    /**
     * Submit a transaction to the Aptos blockchain or something that will do it on your
     * behalf, for example a gas station. See the comments of {@link TransactionSubmitter} for more.
     *
     * @param args - The arguments for submitting the transaction.
     * @param args.aptosConfig - The configuration for connecting to the Aptos network.
     * @param args.transaction - The Aptos transaction data to be submitted.
     * @param args.senderAuthenticator - The account authenticator of the transaction sender.
     * @param args.secondarySignerAuthenticators - Optional. Authenticators for additional signers in a multi-signer transaction.
     * @param args.pluginParams - Optional. Additional parameters for the plugin.
     * @param args.transactionSubmitter - Optional. An override for the transaction submitter.
     *
     * @returns PendingTransactionResponse - The response containing the status of the submitted transaction.
     * @group Implementation
     */
    submitTransaction(args: {
        aptosConfig: AptosConfig;
    } & Omit<InputSubmitTransactionData, "transactionSubmitter">): Promise<PendingTransactionResponse>;
}
/**
 * Represents a client for making requests to a service provider.
 *
 * @param Req - The type of the request payload.
 * @param Res - The type of the response payload.
 */
export interface ClientRequest<Req> {
    url: string;
    method: "GET" | "POST";
    originMethod?: string;
    body?: Req;
    contentType?: string;
    params?: any;
    overrides?: ClientConfig & FullNodeConfig & IndexerConfig & FaucetConfig;
    headers?: Record<string, any>;
    http2?: boolean;
}
export interface ClientResponse<Res> {
    status: number;
    statusText: string;
    data: Res;
    config?: any;
    request?: any;
    response?: any;
    headers?: any;
}
export interface Client {
    /**
     * Sends a request to the specified URL with the given options.
     *
     * @param requestOptions - The options for the request.
     * @param requestOptions.url - The URL to send the request to.
     * @param requestOptions.method - The HTTP method to use, either "GET" or "POST".
     * @param requestOptions.path - An optional path to append to the URL.
     * @param requestOptions.body - The body of the request, applicable for POST requests.
     * @param requestOptions.contentType - The content type of the request body.
     * @param requestOptions.acceptType - The expected content type of the response.
     * @param requestOptions.params - Optional parameters to include in the request.
     * @param requestOptions.originMethod - An optional method to specify the origin of the request.
     * @param requestOptions.overrides - Optional configuration overrides for the request.
     */
    provider<Req, Res>(requestOptions: ClientRequest<Req>): Promise<ClientResponse<Res>>;
}
/**
 * The API request type
 *
 * @param url - the url to make the request to, i.e. https://fullnode.devnet.aptoslabs.com/v1
 * @param method - the request method "GET" | "POST"
 * @param endpoint (optional) - the endpoint to make the request to, i.e. transactions
 * @param body (optional) - the body of the request
 * @param contentType (optional) - the content type to set the `content-type` header to,
 * by default is set to `application/json`
 * @param params (optional) - query params to add to the request
 * @param originMethod (optional) - the local method the request came from
 * @param overrides (optional) - a `ClientConfig` object type to override request data
 */
export type AptosRequest = {
    url: string;
    method: "GET" | "POST";
    path?: string;
    body?: any;
    contentType?: string;
    acceptType?: string;
    params?: Record<string, string | AnyNumber | boolean | undefined>;
    originMethod?: string;
    overrides?: ClientConfig & FullNodeConfig & IndexerConfig & FaucetConfig;
};
/**
 * The API response type
 *
 * @param status - the response status. i.e. 200
 * @param statusText - the response message
 * @param data the response data
 * @param url the url the request was made to
 * @param headers the response headers
 * @param config (optional) - the request object
 * @param request (optional) - the request object
 */
export interface AptosResponse<Req, Res> {
    status: number;
    statusText: string;
    data: Res;
    url: string;
    headers: any;
    config?: any;
    request?: Req;
}
/**
 * The ledger version of transactions, defaulting to the latest version if not specified.
 */
export type LedgerVersionArg = {
    ledgerVersion?: AnyNumber;
};
/**
 * RESPONSE TYPES
 */
/**
 * The output of the estimate gas API, including the deprioritized estimate for the gas unit price.
 */
export type GasEstimation = {
    /**
     * The deprioritized estimate for the gas unit price
     */
    deprioritized_gas_estimate?: number;
    /**
     * The current estimate for the gas unit price
     */
    gas_estimate: number;
    /**
     * The prioritized estimate for the gas unit price
     */
    prioritized_gas_estimate?: number;
};
export type MoveResource<T = {}> = {
    type: MoveStructId;
    data: T;
};
/**
 * The data associated with an account, including its sequence number.
 */
export type AccountData = {
    sequence_number: string;
    authentication_key: string;
};
/**
 * A Move module containing an address.
 */
export type MoveModuleBytecode = {
    bytecode: string;
    abi?: MoveModule;
};
/**
 * TRANSACTION TYPES
 */
/**
 * Different types of transaction responses that can occur in the system.
 */
export declare enum TransactionResponseType {
    Pending = "pending_transaction",
    User = "user_transaction",
    Genesis = "genesis_transaction",
    BlockMetadata = "block_metadata_transaction",
    StateCheckpoint = "state_checkpoint_transaction",
    Validator = "validator_transaction",
    BlockEpilogue = "block_epilogue_transaction"
}
/**
 * The response for a transaction, which can be either pending or committed.
 */
export type TransactionResponse = PendingTransactionResponse | CommittedTransactionResponse;
/**
 * The response for a committed transaction, which can be one of several transaction types.
 */
export type CommittedTransactionResponse = UserTransactionResponse | GenesisTransactionResponse | BlockMetadataTransactionResponse | StateCheckpointTransactionResponse | ValidatorTransactionResponse | BlockEpilogueTransactionResponse;
/**
 * Determine if the given transaction response is currently pending.
 *
 * @param response - The transaction response to evaluate.
 * @returns A boolean indicating whether the transaction is pending.
 */
export declare function isPendingTransactionResponse(response: TransactionResponse): response is PendingTransactionResponse;
/**
 * Determines if the given transaction response is a user transaction.
 *
 * @param response - The transaction response to evaluate.
 * @returns A boolean indicating whether the transaction is of type User.
 */
export declare function isUserTransactionResponse(response: TransactionResponse): response is UserTransactionResponse;
/**
 * Determines if the given transaction response is a Genesis transaction.
 *
 * @param response - The transaction response to evaluate.
 * @returns A boolean indicating whether the transaction is a Genesis transaction.
 */
export declare function isGenesisTransactionResponse(response: TransactionResponse): response is GenesisTransactionResponse;
/**
 * Determine if the given transaction response is of type BlockMetadata.
 *
 * @param response - The transaction response to evaluate.
 * @returns A boolean indicating whether the response is a BlockMetadata transaction.
 */
export declare function isBlockMetadataTransactionResponse(response: TransactionResponse): response is BlockMetadataTransactionResponse;
/**
 * Determines if the provided transaction response is a state checkpoint transaction.
 *
 * @param response - The transaction response to evaluate.
 * @returns A boolean indicating whether the transaction response is of type StateCheckpoint.
 */
export declare function isStateCheckpointTransactionResponse(response: TransactionResponse): response is StateCheckpointTransactionResponse;
/**
 * Determine if the given transaction response is of type Validator.
 *
 * @param response - The transaction response to evaluate.
 * @returns A boolean indicating whether the transaction response is a Validator type.
 */
export declare function isValidatorTransactionResponse(response: TransactionResponse): response is ValidatorTransactionResponse;
/**
 * Determines if the given transaction response is of the type Block Epilogue.
 *
 * @param response - The transaction response to evaluate.
 * @returns A boolean indicating whether the response is a Block Epilogue transaction.
 */
export declare function isBlockEpilogueTransactionResponse(response: TransactionResponse): response is BlockEpilogueTransactionResponse;
/**
 * The response for a pending transaction, indicating that the transaction is still being processed.
 */
export type PendingTransactionResponse = {
    type: TransactionResponseType.Pending;
    hash: string;
    sender: string;
    sequence_number: string;
    max_gas_amount: string;
    gas_unit_price: string;
    expiration_timestamp_secs: string;
    payload: TransactionPayloadResponse;
    signature?: TransactionSignature;
};
/**
 * The response structure for a user transaction.
 */
export type UserTransactionResponse = {
    type: TransactionResponseType.User;
    version: string;
    hash: string;
    state_change_hash: string;
    event_root_hash: string;
    state_checkpoint_hash: string | null;
    gas_used: string;
    /**
     * Whether the transaction was successful
     */
    success: boolean;
    /**
     * The VM status of the transaction, can tell useful information in a failure
     */
    vm_status: string;
    accumulator_root_hash: string;
    /**
     * Final state of resources changed by the transaction
     */
    changes: Array<WriteSetChange>;
    sender: string;
    sequence_number: string;
    replay_protection_nonce: string;
    max_gas_amount: string;
    gas_unit_price: string;
    expiration_timestamp_secs: string;
    payload: TransactionPayloadResponse;
    signature?: TransactionSignature;
    /**
     * Events generated by the transaction
     */
    events: Array<Event>;
    timestamp: string;
};
/**
 * The response for a genesis transaction, indicating the type of transaction.
 */
export type GenesisTransactionResponse = {
    type: TransactionResponseType.Genesis;
    version: string;
    hash: string;
    state_change_hash: string;
    event_root_hash: string;
    state_checkpoint_hash?: string;
    gas_used: string;
    /**
     * Whether the transaction was successful
     */
    success: boolean;
    /**
     * The VM status of the transaction, can tell useful information in a failure
     */
    vm_status: string;
    accumulator_root_hash: string;
    /**
     * Final state of resources changed by the transaction
     */
    changes: Array<WriteSetChange>;
    payload: GenesisPayload;
    /**
     * Events emitted during genesis
     */
    events: Array<Event>;
};
/**
 * The structure representing a blockchain block with its height.
 */
export type BlockMetadataTransactionResponse = {
    type: TransactionResponseType.BlockMetadata;
    version: string;
    hash: string;
    state_change_hash: string;
    event_root_hash: string;
    state_checkpoint_hash: string | null;
    gas_used: string;
    /**
     * Whether the transaction was successful
     */
    success: boolean;
    /**
     * The VM status of the transaction, can tell useful information in a failure
     */
    vm_status: string;
    accumulator_root_hash: string;
    /**
     * Final state of resources changed by the transaction
     */
    changes: Array<WriteSetChange>;
    id: string;
    epoch: string;
    round: string;
    /**
     * The events emitted at the block creation
     */
    events: Array<Event>;
    /**
     * Previous block votes
     */
    previous_block_votes_bitvec: Array<number>;
    proposer: string;
    /**
     * The indices of the proposers who failed to propose
     */
    failed_proposer_indices: Array<number>;
    timestamp: string;
};
/**
 * The response for a state checkpoint transaction, indicating the type of transaction.
 */
export type StateCheckpointTransactionResponse = {
    type: TransactionResponseType.StateCheckpoint;
    version: string;
    hash: string;
    state_change_hash: string;
    event_root_hash: string;
    state_checkpoint_hash: string | null;
    gas_used: string;
    /**
     * Whether the transaction was successful
     */
    success: boolean;
    /**
     * The VM status of the transaction, can tell useful information in a failure
     */
    vm_status: string;
    accumulator_root_hash: string;
    /**
     * Final state of resources changed by the transaction
     */
    changes: Array<WriteSetChange>;
    timestamp: string;
};
/**
 * The response for a validator transaction, indicating the type of transaction.
 */
export type ValidatorTransactionResponse = {
    type: TransactionResponseType.Validator;
    version: string;
    hash: string;
    state_change_hash: string;
    event_root_hash: string;
    state_checkpoint_hash: string | null;
    gas_used: string;
    /**
     * Whether the transaction was successful
     */
    success: boolean;
    /**
     * The VM status of the transaction, can tell useful information in a failure
     */
    vm_status: string;
    accumulator_root_hash: string;
    /**
     * Final state of resources changed by the transaction
     */
    changes: Array<WriteSetChange>;
    /**
     * The events emitted by the validator transaction
     */
    events: Array<Event>;
    timestamp: string;
};
/**
 * Describes the gas state of the block, indicating whether the block gas limit has been reached.
 */
export type BlockEndInfo = {
    block_gas_limit_reached: boolean;
    block_output_limit_reached: boolean;
    block_effective_block_gas_units: number;
    block_approx_output_size: number;
};
/**
 * A transaction executed at the end of a block that tracks data from the entire block.
 */
export type BlockEpilogueTransactionResponse = {
    type: TransactionResponseType.BlockEpilogue;
    version: string;
    hash: string;
    state_change_hash: string;
    event_root_hash: string;
    state_checkpoint_hash: string | null;
    gas_used: string;
    /**
     * Whether the transaction was successful
     */
    success: boolean;
    /**
     * The VM status of the transaction, can tell useful information in a failure
     */
    vm_status: string;
    accumulator_root_hash: string;
    /**
     * Final state of resources changed by the transaction
     */
    changes: Array<WriteSetChange>;
    timestamp: string;
    block_end_info: BlockEndInfo | null;
};
/**
 * WRITESET CHANGE TYPES
 */
/**
 * A union type that encompasses both script and direct write sets for data operations.
 */
export type WriteSetChange = WriteSetChangeDeleteModule | WriteSetChangeDeleteResource | WriteSetChangeDeleteTableItem | WriteSetChangeWriteModule | WriteSetChangeWriteResource | WriteSetChangeWriteTableItem;
/**
 * The structure for a module deletion change in a write set.
 */
export type WriteSetChangeDeleteModule = {
    type: string;
    address: string;
    /**
     * State key hash
     */
    state_key_hash: string;
    module: MoveModuleId;
};
/**
 * The payload for a resource deletion in a write set change.
 */
export type WriteSetChangeDeleteResource = {
    type: string;
    address: string;
    state_key_hash: string;
    resource: string;
};
/**
 * The payload for a write set change that deletes a table item.
 */
export type WriteSetChangeDeleteTableItem = {
    type: string;
    state_key_hash: string;
    handle: string;
    key: string;
    data?: DeletedTableData;
};
/**
 * The structure for a write module change in a write set.
 */
export type WriteSetChangeWriteModule = {
    type: string;
    address: string;
    state_key_hash: string;
    data: MoveModuleBytecode;
};
/**
 * The resource associated with a write set change, identified by its type.
 */
export type WriteSetChangeWriteResource = {
    type: string;
    address: string;
    state_key_hash: string;
    data: MoveResource;
};
/**
 * The structure for a write operation on a table in a write set change.
 */
export type WriteSetChangeWriteTableItem = {
    type: string;
    state_key_hash: string;
    handle: string;
    key: string;
    value: string;
    data?: DecodedTableData;
};
/**
 * The decoded data for a table, including its key in JSON format.
 */
export type DecodedTableData = {
    /**
     * Key of table in JSON
     */
    key: any;
    /**
     * Type of key
     */
    key_type: string;
    /**
     * Value of table in JSON
     */
    value: any;
    /**
     * Type of value
     */
    value_type: string;
};
/**
 * Data for a deleted table entry.
 */
export type DeletedTableData = {
    /**
     * Deleted key
     */
    key: any;
    /**
     * Deleted key type
     */
    key_type: string;
};
/**
 * Claimed entry function metadata on encrypted transaction payloads (REST API uses `name` for the optional function identifier).
 */
export type ClaimedEntryFunctionResponse = {
    module: string;
    name?: string;
};
/**
 * Encrypted payload response when the node has not yet decrypted it, or decryption failed.
 * Narrow on `encrypted_state` to distinguish from {@link DecryptedEncryptedTransactionPayloadResponse}.
 */
export type EncryptedEncryptedTransactionPayloadResponse = {
    type: string;
    encrypted_state: "encrypted" | "failed_decryption";
    payload_hash: string;
    ciphertext: string;
    claimed_entry_fun: ClaimedEntryFunctionResponse | null;
    /** Ledger epoch hint for the encryption key used on the wire (aptos-core `EncryptedInner.encryption_epoch`). */
    encryption_epoch?: string;
    /** Present when `encrypted_state` is `failed_decryption`. Not yet surfaced by the REST API; reserved for future use. */
    decryption_failure_reason?: string;
};
/**
 * Encrypted payload response after the node has successfully decrypted it.
 * Narrow on `encrypted_state === "decrypted"` to access `decrypted_payload`.
 */
export type DecryptedEncryptedTransactionPayloadResponse = {
    type: string;
    encrypted_state: "decrypted";
    payload_hash: string;
    ciphertext: string;
    claimed_entry_fun: ClaimedEntryFunctionResponse | null;
    decrypted_payload: EntryFunctionPayloadResponse | ScriptPayloadResponse | MultisigPayloadResponse;
    decryption_nonce: string;
    encryption_epoch?: string;
};
/**
 * Encrypted transaction payload as returned by the API. Discriminate on `encrypted_state`:
 * - `"encrypted"` / `"failed_decryption"` → {@link EncryptedEncryptedTransactionPayloadResponse}
 * - `"decrypted"` → {@link DecryptedEncryptedTransactionPayloadResponse}
 */
export type EncryptedTransactionPayloadResponse = EncryptedEncryptedTransactionPayloadResponse | DecryptedEncryptedTransactionPayloadResponse;
/**
 * The payload for a transaction response, which can be an entry function, script, multisig, or encrypted payload.
 */
export type TransactionPayloadResponse = EntryFunctionPayloadResponse | ScriptPayloadResponse | MultisigPayloadResponse | EncryptedTransactionPayloadResponse;
/**
 * The response payload for an entry function, containing the type of the entry.
 */
export type EntryFunctionPayloadResponse = {
    type: string;
    function: MoveFunctionId;
    /**
     * Type arguments of the function
     */
    type_arguments: Array<string>;
    /**
     * Arguments of the function
     */
    arguments: Array<any>;
};
/**
 * The payload for a script response, containing the type of the script.
 */
export type ScriptPayloadResponse = {
    type: string;
    code: MoveScriptBytecode;
    /**
     * Type arguments of the function
     */
    type_arguments: Array<string>;
    /**
     * Arguments of the function
     */
    arguments: Array<any>;
};
/**
 * The response payload for a multisig transaction, containing the type of the transaction.
 */
export type MultisigPayloadResponse = {
    type: string;
    multisig_address: string;
    transaction_payload?: EntryFunctionPayloadResponse;
};
/**
 * The payload for the genesis block containing the type of the payload.
 */
export type GenesisPayload = {
    type: string;
    write_set: WriteSet;
};
/**
 * The bytecode for a Move script.
 */
export type MoveScriptBytecode = {
    bytecode: string;
    abi?: MoveFunction;
};
/**
 * JSON representations of transaction signatures returned from the node API.
 */
export type TransactionSignature = TransactionEd25519Signature | TransactionSecp256k1Signature | TransactionMultiEd25519Signature | TransactionMultiAgentSignature | TransactionFeePayerSignature | TransactionSingleSenderSignature;
/**
 * Determine if the provided signature is an Ed25519 signature.
 * This function checks for the presence of the "signature" property
 * and verifies that its value is "ed25519_signature".
 *
 * @param signature - The transaction signature to be checked.
 * @returns A boolean indicating whether the signature is an Ed25519 signature.
 */
export declare function isEd25519Signature(signature: TransactionSignature): signature is TransactionEd25519Signature;
/**
 * Determine if the provided signature is a valid secp256k1 ECDSA signature.
 *
 * @param signature - The transaction signature to validate.
 * @returns A boolean indicating whether the signature is a secp256k1 ECDSA signature.
 */
export declare function isSecp256k1Signature(signature: TransactionSignature): signature is TransactionFeePayerSignature;
/**
 * Determine if the provided transaction signature is a multi-agent signature.
 *
 * @param signature - The transaction signature to evaluate.
 * @returns A boolean indicating whether the signature is a multi-agent signature.
 */
export declare function isMultiAgentSignature(signature: TransactionSignature): signature is TransactionMultiAgentSignature;
/**
 * Determine if the provided signature is a fee payer signature.
 *
 * @param signature - The transaction signature to evaluate.
 * @returns A boolean indicating whether the signature is a fee payer signature.
 */
export declare function isFeePayerSignature(signature: TransactionSignature): signature is TransactionFeePayerSignature;
/**
 * Determine if the provided signature is of type "multi_ed25519_signature".
 *
 * @param signature - The transaction signature to check.
 * @returns A boolean indicating whether the signature is a multi-ed25519 signature.
 */
export declare function isMultiEd25519Signature(signature: TransactionSignature): signature is TransactionMultiEd25519Signature;
/**
 * Determine if the provided signature is of type "single_sender".
 *
 * @param signature - The transaction signature to check.
 * @returns A boolean indicating whether the signature is a single-sender signature.
 */
export declare function isSingleSenderSignature(signature: TransactionSignature): signature is TransactionSingleSenderSignature;
/**
 * The signature for a transaction using the Ed25519 algorithm.
 */
export type TransactionEd25519Signature = {
    type: string;
    public_key: string;
    signature: "ed25519_signature";
};
/**
 * The structure for a Secp256k1 signature in a transaction.
 */
export type TransactionSecp256k1Signature = {
    type: string;
    public_key: string;
    signature: "secp256k1_ecdsa_signature";
};
/**
 * The structure for a multi-signature transaction using Ed25519.
 */
export type TransactionSingleSenderSignature = {
    type: "single_sender";
    public_key: {
        value: string;
        type: string;
    };
    signature: {
        value: string;
        type: string;
    };
};
/**
 * The structure for a multi-signature transaction using Ed25519.
 */
export type TransactionMultiEd25519Signature = {
    type: "multi_ed25519_signature";
    /**
     * The public keys for the Ed25519 signature
     */
    public_keys: Array<string>;
    /**
     * Signature associated with the public keys in the same order
     */
    signatures: Array<string>;
    /**
     * The number of signatures required for a successful transaction
     */
    threshold: number;
    bitmap: string;
};
/**
 * The structure for a multi-agent signature in a transaction.
 */
export type TransactionMultiAgentSignature = {
    type: "multi_agent_signature";
    sender: AccountSignature;
    /**
     * The other involved parties' addresses
     */
    secondary_signer_addresses: Array<string>;
    /**
     * The associated signatures, in the same order as the secondary addresses
     */
    secondary_signers: Array<AccountSignature>;
};
/**
 * The signature of the fee payer in a transaction.
 */
export type TransactionFeePayerSignature = {
    type: "fee_payer_signature";
    sender: AccountSignature;
    /**
     * The other involved parties' addresses
     */
    secondary_signer_addresses: Array<string>;
    /**
     * The associated signatures, in the same order as the secondary addresses
     */
    secondary_signers: Array<AccountSignature>;
    fee_payer_address: string;
    fee_payer_signer: AccountSignature;
};
/**
 * The union of all single account signatures, including Ed25519, Secp256k1, and MultiEd25519 signatures.
 */
export type AccountSignature = TransactionEd25519Signature | TransactionSecp256k1Signature | TransactionMultiEd25519Signature;
export type WriteSet = ScriptWriteSet | DirectWriteSet;
/**
 * The set of properties for writing scripts, including the type of script.
 */
export type ScriptWriteSet = {
    type: string;
    execute_as: string;
    script: ScriptPayloadResponse;
};
/**
 * The set of direct write operations, identified by a type string.
 */
export type DirectWriteSet = {
    type: string;
    changes: Array<WriteSetChange>;
    events: Array<Event>;
};
/**
 * The structure for an event's unique identifier, including its creation number.
 */
/**
 * The structure for an event, identified by a unique GUID.
 */
export type EventGuid = {
    creation_number: string;
    account_address: string;
};
export type Event = {
    guid: EventGuid;
    sequence_number: string;
    type: string;
    /**
     * The JSON representation of the event
     */
    data: any;
};
/**
 * A number representing a Move uint8 type.
 */
export type MoveUint8Type = number;
/**
 * A 16-bit unsigned integer used in the Move programming language.
 */
export type MoveUint16Type = number;
/**
 * A 32-bit unsigned integer type used in Move programming.
 */
export type MoveUint32Type = number;
/**
 * A string representation of a 64-bit unsigned integer used in Move programming.
 */
export type MoveUint64Type = string;
/**
 * A string representing a 128-bit unsigned integer in the Move programming language.
 */
export type MoveUint128Type = string;
/**
 * A string representation of a 256-bit unsigned integer used in Move programming.
 */
export type MoveUint256Type = string;
/**
 * A number representing a Move int8 type.
 */
export type MoveInt8Type = number;
/**
 * A 16-bit signed integer used in the Move programming language.
 */
export type MoveInt16Type = number;
/**
 * A 32-bit signed integer type used in Move programming.
 */
export type MoveInt32Type = number;
/**
 * A string representation of a 64-bit signed integer used in Move programming.
 */
export type MoveInt64Type = string;
/**
 * A string representing a 128-bit signed integer in the Move programming language.
 */
export type MoveInt128Type = string;
/**
 * A string representation of a 256-bit signed integer used in Move programming.
 */
export type MoveInt256Type = string;
/**
 * A string representing a Move address.
 */
export type MoveAddressType = string;
/**
 * The type for identifying objects to be moved within the system.
 */
export type MoveObjectType = string;
/**
 * The type for move options, which can be a MoveType, null, or undefined.
 */
export type MoveOptionType = MoveType | null | undefined;
/**
 * A structure representing a move with a name.
 */
export type MoveStructId = `${string}::${string}::${string}`;
/**
 * The move function containing its name. Same as MoveStructId since it reads weird to take a StructId for a Function.
 */
export type MoveFunctionId = MoveStructId;
export type MoveStructType = {};
/**
 * A union type that encompasses various data types used in Move, including primitive types, address types, object types, and
 * arrays of MoveType.
 */
export type MoveType = boolean | string | MoveUint8Type | MoveUint16Type | MoveUint32Type | MoveUint64Type | MoveUint128Type | MoveUint256Type | MoveInt8Type | MoveInt16Type | MoveInt32Type | MoveInt64Type | MoveInt128Type | MoveInt256Type | MoveAddressType | MoveObjectType | MoveStructType | Array<MoveType>;
/**
 * Possible Move values acceptable by move functions (entry, view)
 *
 * Map of a Move value to the corresponding TypeScript value
 *
 * `Bool -> boolean`
 *
 * `u8, u16, u32 -> number`
 *
 * `u64, u128, u256 -> string`
 *
 * `i8, i16, i32 -> number`
 *
 * `i64, i128, i256 -> string`
 *
 * `String -> string`
 *
 * `Address -> 0x${string}`
 *
 * `Struct - 0x${string}::${string}::${string}`
 *
 * `Object -> 0x${string}`
 *
 * `Vector -> Array<MoveValue>`
 *
 * `Option -> MoveValue | null | undefined`
 */
export type MoveValue = boolean | string | MoveUint8Type | MoveUint16Type | MoveUint32Type | MoveUint64Type | MoveUint128Type | MoveUint256Type | MoveInt8Type | MoveInt16Type | MoveInt32Type | MoveInt64Type | MoveInt128Type | MoveInt256Type | MoveAddressType | MoveObjectType | MoveStructId | MoveOptionType | Array<MoveValue>;
/**
 * A string representation of a Move module, formatted as `module_name::function_name`.
 * Module names are case-sensitive.
 */
export type MoveModuleId = `${string}::${string}`;
/**
 * Specifies the visibility levels for move functions, controlling access permissions.
 */
export declare enum MoveFunctionVisibility {
    PRIVATE = "private",
    PUBLIC = "public",
    FRIEND = "friend"
}
/**
 * Abilities related to moving items within the system.
 */
export declare enum MoveAbility {
    STORE = "store",
    DROP = "drop",
    KEY = "key",
    COPY = "copy"
}
/**
 * Move abilities associated with the generic type parameter of a function.
 */
export type MoveFunctionGenericTypeParam = {
    constraints: Array<MoveAbility>;
};
/**
 * A field in a Move struct, identified by its name.
 */
export type MoveStructField = {
    name: string;
    type: string;
};
/**
 * A Move module
 */
export type MoveModule = {
    address: string;
    name: string;
    /**
     * Friends of the module
     */
    friends: Array<MoveModuleId>;
    /**
     * Public functions of the module
     */
    exposed_functions: Array<MoveFunction>;
    /**
     * Structs of the module
     */
    structs: Array<MoveStruct>;
};
/**
 * A move struct
 */
export type MoveStruct = {
    name: string;
    /**
     * Whether the struct is a native struct of Move
     */
    is_native: boolean;
    /**
     * Whether the struct is a module event (aka v2 event). This will be false for v1
     * events because the value is derived from the #[event] attribute on the struct in
     * the Move source code. This attribute is only relevant for v2 events.
     */
    is_event: boolean;
    /**
     * True if the struct is an enum (e.g. enum MyEnum { A, B, C }), false if it is a
     * regular struct (e.g. struct MyStruct { a: u8, b: u8 }).
     */
    is_enum: boolean;
    /**
     * Abilities associated with the struct
     */
    abilities: Array<MoveAbility>;
    /**
     * Generic types associated with the struct
     */
    generic_type_params: Array<MoveFunctionGenericTypeParam>;
    /**
     * Fields associated with the struct
     */
    fields: Array<MoveStructField>;
};
/**
 * Move function
 */
export type MoveFunction = {
    name: string;
    visibility: MoveFunctionVisibility;
    /**
     * Whether the function can be called as an entry function directly in a transaction
     */
    is_entry: boolean;
    /**
     * Whether the function is a view function or not
     */
    is_view: boolean;
    /**
     * Generic type params associated with the Move function
     */
    generic_type_params: Array<MoveFunctionGenericTypeParam>;
    /**
     * Parameters associated with the move function
     */
    params: Array<string>;
    /**
     * Return type of the function
     */
    return: Array<string>;
};
/**
 * Roles that can be assigned within the system, indicating different levels of access and functionality.
 */
export declare enum RoleType {
    VALIDATOR = "validator",
    FULL_NODE = "full_node"
}
/**
 * Information about the current blockchain ledger, including its chain ID.
 */
export type LedgerInfo = {
    /**
     * Chain ID of the current chain
     */
    chain_id: number;
    epoch: string;
    ledger_version: string;
    oldest_ledger_version: string;
    ledger_timestamp: string;
    node_role: RoleType;
    oldest_block_height: string;
    block_height: string;
    /**
     * Git hash of the build of the API endpoint.  Can be used to determine the exact
     * software version used by the API endpoint.
     */
    git_hash?: string;
    /**
     * Hex-encoded encryption key for encrypted transactions.
     * Present when the node supports encrypted transaction submission.
     */
    encryption_key?: string;
};
/**
 * A Block type
 */
export type Block = {
    block_height: string;
    block_hash: string;
    block_timestamp: string;
    first_version: string;
    last_version: string;
    /**
     * The transactions in the block in sequential order
     */
    transactions?: Array<TransactionResponse>;
};
/**
 * The request payload for the GetTableItem API.
 */
export type TableItemRequest = {
    key_type: MoveValue;
    value_type: MoveValue;
    /**
     * The value of the table item's key
     */
    key: any;
};
/**
 * A list of supported Authentication Key schemes in Aptos, consisting of combinations of signing schemes and derive schemes.
 */
export type AuthenticationKeyScheme = SigningScheme | DeriveScheme;
/**
 * Different schemes for signing keys used in cryptographic operations.
 */
export declare enum SigningScheme {
    /**
     * For Ed25519PublicKey
     */
    Ed25519 = 0,
    /**
     * For MultiEd25519PublicKey
     */
    MultiEd25519 = 1,
    /**
     * For SingleKey ecdsa
     */
    SingleKey = 2,
    MultiKey = 3
}
/**
 * Specifies the signing schemes available for cryptographic operations.
 */
export declare enum SigningSchemeInput {
    /**
     * For Ed25519PublicKey
     */
    Ed25519 = 0,
    /**
     * For Secp256k1Ecdsa
     */
    Secp256k1Ecdsa = 2
}
/**
 * Specifies the schemes for deriving account addresses from various data sources.
 */
export declare enum DeriveScheme {
    /**
     * Derives an address using an AUID, used for objects
     */
    DeriveAuid = 251,
    /**
     * Derives an address from another object address
     */
    DeriveObjectAddressFromObject = 252,
    /**
     * Derives an address from a GUID, used for objects
     */
    DeriveObjectAddressFromGuid = 253,
    /**
     * Derives an address from seed bytes, used for named objects
     */
    DeriveObjectAddressFromSeed = 254,
    /**
     * Derives an address from seed bytes, used for resource accounts
     */
    DeriveResourceAccountAddress = 255
}
/**
 * Options for configuring the behavior of the waitForTransaction() function.
 */
export type WaitForTransactionOptions = {
    timeoutSecs?: number;
    checkSuccess?: boolean;
    waitForIndexer?: boolean;
};
/**
 * Input type to generate an account using the Ed25519 signing scheme.
 */
export type GenerateAccountWithEd25519 = {
    scheme: SigningSchemeInput.Ed25519;
    legacy: boolean;
};
/**
 * Input type to generate an account with a Single Signer using Secp256k1.
 */
export type GenerateAccountWithSingleSignerSecp256k1Key = {
    scheme: SigningSchemeInput.Secp256k1Ecdsa;
    legacy?: false;
};
export type GenerateAccount = GenerateAccountWithEd25519 | GenerateAccountWithSingleSignerSecp256k1Key;
//# sourceMappingURL=types.d.ts.map