import { SocketClient } from './socket-client';
import { CallbackManager } from './callback-manager';
import { WalletResponse, RequestRequest, MessageBody, SubscribeRequest, AuthenticateRequest, NewAddressResponse, TxRequest, NamespacesResponse, InstrumentResponse, AuthenticateResponse, ErrorResponse, RegisterAssetResponse, RegisterNamespaceResponse, Address, IssueAssetResponse, RawBeneficiary, EncumbranceResponse, RawAdministrator, UnencumberAssetResponse, Party, NewContractResponse, HoldingsDetailResponse, ServerMessageRequest, SigUpdateResponse, ILogger, IJsonPoster, RawPublicKey, RawAddressString, ContractsResponse } from './interfaces';
import { WalletNodeEmitter } from './emitter';
import { Observable } from 'rxjs';
import { StateService } from '../../services/state';
import { ExerciseEncumbranceRequest, HoldingsDetailRequest, HoldingsDetailsRequest, HoldingsRequest, IssuerTransferRequest, NamespaceRequest, NewAddressRequest, TransferFromManyRequest } from '../../types';
import { CreateContract } from '../../contract/interfaces';
/**
 * Wallet Node Client class
 */
export declare class WalletNodeClient extends WalletNodeEmitter {
    private walletNodeSocket;
    private callback;
    private poster;
    private logger;
    seenTransactions: {};
    private events;
    /**
     * Constructor
     *
     * @param {SocketClient} walletNodeSocket Wallet Node Socket Client
     * @param {CallbackManager} callback CallBack Manager
     */
    constructor(walletNodeSocket: SocketClient, callback: CallbackManager, poster: IJsonPoster, logger: ILogger);
    get events$(): Observable<unknown>;
    txReceipt({ message: { data: { hash } } }: {
        message: {
            data: {
                hash: any;
            };
        };
    }): Promise<unknown>;
    /**
     * Connect to Wallet Node
     *
     * @return void
     */
    connect(): Promise<void>;
    disconnect(): void;
    /**
     * Send Request to Wallet Node
     *
     * @param {any} request Request JSON Object
     *
     * @returns {Promise<any>}
     */
    sendRequest<T extends MessageBody, R>(request: RequestRequest<T> | TxRequest<T> | SubscribeRequest | AuthenticateRequest | ServerMessageRequest<T>): Promise<WalletResponse<R> | ErrorResponse>;
    /**
     * Authenticate
     *
     * @param {number} userId     User Id
     * @param {string} userApiKey User API Key
     *
     * @returns {Promise<any>}
     */
    authenticate(userId: number, userApiKey: string): Promise<ErrorResponse | WalletResponse<AuthenticateResponse>>;
    /**
     * Get Blockchain State
     *
     * @returns {Promise<any>}
     */
    state(): Promise<any>;
    ping(): Promise<any>;
    block(): Promise<any>;
    access(): Promise<any>;
    /**
     * Subscribe to Wallet Node Events
     *
     * @param {string[]} events
     *
     * @return {void}
     */
    subscribe(...events: string[]): void;
    newAddress(payload: NewAddressRequest): Promise<WalletResponse<NewAddressResponse>>;
    namespaces(): Promise<WalletResponse<NamespacesResponse>>;
    namespaces(walletId: number): Promise<WalletResponse<NamespacesResponse>>;
    namespaces(walletId: number, namespace: string): Promise<WalletResponse<NamespacesResponse>>;
    namespaces(walletId: number, namespace: string, address: string): Promise<WalletResponse<NamespacesResponse>>;
    instruments(walletid?: number): Promise<InstrumentResponse>;
    namespace(payload: NamespaceRequest): Promise<WalletResponse<any>>;
    addresses(walletid: number): Promise<Address[]>;
    contracts(walletid: number): Promise<WalletResponse<ContractsResponse[]>>;
    /**
     * Get a single Contract by address
     */
    contract(walletid: number, address: string): Promise<WalletResponse<ContractsResponse>>;
    registerNamespace(walletid: number, address: string, name: string, metadata?: string): Promise<WalletResponse<RegisterNamespaceResponse>>;
    registerAsset(walletid: number, address: string, namespace: string, instrument: string, metadata?: string): Promise<WalletResponse<RegisterAssetResponse>>;
    issueAsset(walletid: number, address: string, namespace: string, instrument: string, amount: number): Promise<WalletResponse<IssueAssetResponse>>;
    encumberAsset(walletid: number, address: string, subjectaddress: string, reference: string, namespace: string, instrument: string, amount: number, beneficiaries: RawBeneficiary[], administrators: RawAdministrator[], iscumulative: boolean, metadata?: any): Promise<WalletResponse<EncumbranceResponse>>;
    unencumberAsset(walletid: number, address: string, subjectaddress: string, reference: string, namespace: string, instrument: string, amount: number): Promise<WalletResponse<UnencumberAssetResponse>>;
    sigUpdate(userId: number, walletIds: number[]): Promise<SigUpdateResponse>;
    createContract(payload: CreateContract): Promise<WalletResponse<NewContractResponse>>;
    /**
     * Sign an authorisaion in given contract.
     * @param walletId Wallet ID of authoriser
     * @param address Address of authoriser
     * @param contractAddress Address of contract
     * @param authorisationId ID of authorisation
     * @param metadata User metadata
     */
    contractAuthorise(walletId: number, address: RawAddressString | RawPublicKey, contractAddress: string, authorisationId: string, metadata: string): Promise<WalletResponse<any>>;
    /**
     * Sign a party, including all payments.
     * @param walletId Signing party's wallet ID
     * @param address Signing party's address
     * @param contractAddress Contract address to sign
     * @param party Party to sign
     */
    signParty(walletId: number, address: RawAddressString | RawPublicKey, contractAddress: string, party: Party): Promise<WalletResponse<any>>;
    holders(walletId: number, namespace?: string, instrument?: string): Promise<WalletResponse<any>>;
    holdings(payload: HoldingsRequest): Promise<WalletResponse<any>>;
    holdingsDetail(payload: HoldingsDetailRequest): Promise<WalletResponse<HoldingsDetailResponse>>;
    holdingsDetails(payload: HoldingsDetailsRequest): Promise<WalletResponse<HoldingsDetailResponse>>;
    /**
     * Get the next block.
     */
    nextBlock(): Promise<any>;
    /**
     * Wait for contract to be created in state.
     */
    newContract(contractAddress: string): Promise<unknown>;
    /**
     * Listen for updates to contracts.
     */
    contractChanges(contractAddress?: string): Observable<string>;
    transferAsset(payload: any): Promise<any>;
    encumumberPayload(payload: any): Promise<any>;
    excersiseEncumbrancePayload(payload: ExerciseEncumbranceRequest): Promise<any>;
    issueAssetPayload(payload: any): Promise<any>;
    issuerTransferPayload(payload: IssuerTransferRequest): Promise<any>;
    nullTxPayload(payload: any): Promise<any>;
    registerAssetPayload(payload: any): Promise<any>;
    registerNamespacePayload(payload: any): Promise<any>;
    transferFromManyPayload(payload: TransferFromManyRequest): Promise<any>;
    private payloadRequest;
}
export declare function newClient(stateService: StateService): Promise<WalletNodeClient>;
