import { EventEmitter } from 'events';
import type { Transport } from './transports/types';
import type { TransportOptions } from './transports/types';
import type { ApiMethodSignatures } from './types';
interface ApiOptions {
    url?: string;
    transport?: string | (new (options: TransportOptions) => Transport);
    logger?: Logger;
    useTestNet?: boolean;
    useAppbaseApi?: boolean;
    fetchMethod?: typeof fetch;
    [key: string]: unknown;
}
interface Logger {
    log: (...args: unknown[]) => void;
    [key: string]: (...args: unknown[]) => void;
}
export declare class Api extends EventEmitter {
    private seqNo;
    private _transportType;
    private transport;
    private options;
    private __logger;
    [key: string]: unknown;
    getAccounts: ApiMethodSignatures['getAccounts'];
    getAccountsAsync: ApiMethodSignatures['getAccountsAsync'];
    getAccountsWith: ApiMethodSignatures['getAccountsWith'];
    getAccountsWithAsync: ApiMethodSignatures['getAccountsWithAsync'];
    private static _wrapWithPromise;
    constructor(options?: ApiOptions);
    private _setTransport;
    private _setLogger;
    log(logLevel: string, ...args: unknown[]): void;
    start(): Promise<void>;
    stop(): Promise<void>;
    send(api: string, data: unknown, callback: unknown): void | Promise<void>;
    call(method: string, params: unknown[], callback: (err: Error | null, result?: unknown) => void): void;
    /**
     * Promise-based version of call
     * Makes a JSON-RPC call to the Steem blockchain
     * @param method Method name (e.g., 'condenser_api.get_accounts')
     * @param params Parameters array for the method
     * @returns Promise that resolves with the result or rejects with an error
     */
    callAsync(method: string, params: unknown[]): Promise<unknown>;
    signedCall(method: string, params: unknown[], account: string, key: string, callback: (err: Error | null, result?: unknown) => void): void;
    /**
     * Promise-based version of signedCall
     * Makes an authenticated JSON-RPC call with cryptographic signature
     * @param method Method name (e.g., 'conveyor.is_email_registered')
     * @param params Parameters array for the method
     * @param account Account name to sign the request with
     * @param key Private key (WIF) to sign the request
     * @returns Promise that resolves with the result or rejects with an error
     */
    signedCallAsync(method: string, params: unknown[], account: string, key: string): Promise<unknown>;
    /**
     * Verify a signed RPC request
     * @param signedRequest The signed request to verify
     * @param callback Callback function
     */
    verifySignedRequest(signedRequest: unknown, callback: (err: Error | null, result?: unknown) => void): void;
    /**
     * Promise-based version of verifySignedRequest
     * Verifies a signed RPC request
     * @param signedRequest The signed request to verify
     * @returns Promise that resolves with verification result or rejects with an error
     */
    verifySignedRequestAsync(signedRequest: unknown): Promise<{
        valid: boolean;
        params: unknown;
    }>;
    setOptions(options: ApiOptions): void;
    setUrl(url: string): void;
    streamBlockNumber(mode?: string | ((err: Error | null, blockNumber?: unknown) => void), callback?: (err: Error | null, blockNumber?: unknown) => void, ts?: number): () => void;
    streamBlock(mode: string | undefined, callback: (err: Error | null, block?: unknown) => void): () => void;
    streamTransactions(mode?: string | ((err: Error | null, tx?: unknown) => void), callback?: (err: Error | null, tx?: unknown) => void): () => void;
    streamOperations(mode?: string | ((err: Error | null, op?: unknown) => void), callback?: (err: Error | null, op?: unknown) => void): () => void;
    broadcastTransactionSynchronousWith(options: {
        transaction: unknown;
    }, callback: (err: Error | null, result?: unknown) => void): void;
    /**
     * Promise-based version of broadcastTransactionSynchronousWith
     * Broadcasts a transaction synchronously
     * @param options Options object containing the transaction
     * @returns Promise that resolves with the result or rejects with an error
     */
    broadcastTransactionSynchronousWithAsync(options: {
        transaction: unknown;
    }): Promise<unknown>;
    /**
     * Broadcast a transaction to the blockchain.
     * @param trx The transaction object
     * @param callback Callback function
     */
    broadcastTransaction(trx: unknown, callback: (err: Error | null, result?: unknown) => void): void;
    /**
     * Promise-based version of broadcastTransaction
     * Broadcasts a transaction to the blockchain
     * @param trx The transaction object
     * @returns Promise that resolves with the result or rejects with an error
     */
    broadcastTransactionAsync(trx: unknown): Promise<unknown>;
    /**
     * Sign a transaction with the provided private key(s).
     * @param trx The transaction object
     * @param keys Array of WIF private keys
     * @returns Signed transaction object
     */
    signTransaction(trx: unknown, keys: string[]): unknown;
    /**
     * Get followers for an account (backward compatibility).
     * @param account The account name
     * @param startFollower The follower to start from
     * @param type The type of follow
     * @param limit The number of followers to return
     * @param callback Optional callback
     * @returns Array of followers or Promise
     */
    getFollowers(account: string, startFollower: string, type: string, limit: number, callback?: (err: Error | null, result?: unknown[]) => void): Promise<unknown[]> | void;
    /**
     * Broadcast a transaction with a confirmation callback.
     * @param confirmationCallback Callback function for transaction confirmation
     * @param trx Transaction object to broadcast
     * @param callback Callback function
     */
    broadcastTransactionWithCallback(confirmationCallback: (result: unknown) => void, trx: unknown, callback: (err: Error | null, result?: unknown) => void): void;
    /**
     * Promise-based version of broadcastTransactionWithCallback
     * Note: The confirmationCallback will still be called when the transaction is confirmed
     * @param confirmationCallback Callback function for transaction confirmation
     * @param trx Transaction object to broadcast
     * @returns Promise that resolves with the result or rejects with an error
     */
    broadcastTransactionWithCallbackAsync(confirmationCallback: (result: unknown) => void, trx: unknown): Promise<unknown>;
    /**
     * Broadcast a block to the network.
     * @param block Block object to broadcast
     * @param callback Callback function
     */
    broadcastBlock(block: unknown, callback: (err: Error | null, result?: unknown) => void): void;
    /**
     * Promise-based version of broadcastBlock
     * Broadcasts a block to the network
     * @param block Block object to broadcast
     * @returns Promise that resolves with the result or rejects with an error
     */
    broadcastBlockAsync(block: unknown): Promise<unknown>;
    /**
     * Set the maximum block age for transaction acceptance.
     * @param maxBlockAge Maximum block age in seconds
     * @param callback Callback function
     */
    setMaxBlockAge(maxBlockAge: number, callback: (err: Error | null, result?: unknown) => void): void;
    /**
     * Promise-based version of setMaxBlockAge
     * Sets the maximum block age for transaction acceptance
     * @param maxBlockAge Maximum block age in seconds
     * @returns Promise that resolves with the result or rejects with an error
     */
    setMaxBlockAgeAsync(maxBlockAge: number): Promise<unknown>;
    /**
     * Verify transaction authority.
     * @param trx Transaction object to verify
     * @param callback Optional callback function
     * @returns Promise with verification result if no callback provided
     */
    verifyAuthority(trx: unknown, callback?: (err: Error | null, result?: boolean) => void): Promise<boolean> | void;
    /**
     * Verify account authority.
     * @param nameOrId Account name or ID
     * @param signers Array of signer public keys
     * @param callback Optional callback function
     * @returns Promise with verification result if no callback provided
     */
    verifyAccountAuthority(nameOrId: string, signers: string[], callback?: (err: Error | null, result?: boolean) => void): Promise<boolean> | void;
}
declare const api: Api;
export declare function setOptions(options: ApiOptions): void;
export declare function call(method: string, params: unknown[], callback: (err: Error | null, result?: unknown) => void): void;
export declare function signTransaction(trx: unknown, keys: string[]): unknown;
export declare function verifyAuthority(..._args: unknown[]): boolean;
export default api;
export declare const getDynamicGlobalPropertiesAsync: () => Promise<unknown>;
export declare const getBlockAsync: (...args: unknown[]) => Promise<unknown>;
export declare const getFollowersAsync: (...args: unknown[]) => Promise<unknown>;
export declare const getContentAsync: (...args: unknown[]) => Promise<unknown>;
export declare const listeners: (...args: unknown[]) => unknown;
export declare const streamBlockNumber: (...args: unknown[]) => unknown;
export declare const streamBlock: (...args: unknown[]) => unknown;
export declare const streamTransactions: (...args: unknown[]) => unknown;
export declare const streamOperations: (...args: unknown[]) => unknown;
export { sign as signRequest, validate as validateRequest } from './rpc-auth';
export * as signatureVerification from './signature-verification';