import type { Overrides } from '@ethersproject/contracts';
import { EthereumAddress } from '@streamr/utils';
import type { Schema } from 'ajv';
import { ContractTransaction, Signer } from 'ethers';
import 'reflect-metadata';
import { MessageListener, Stream, StreamDefinition, StreamrClient } from 'streamr-client';
import { LogStoreClientEvents } from './events';
import { LogStoreClientConfig } from './LogStoreClientConfig';
import { LogStoreMessageStream } from './LogStoreMessageStream';
import { HttpApiQueryDict, QueryInput, type QueryOptions, QueryType } from './Queries';
import { StreamObservableFactory } from './StreamObservableFactory';
import { AmountTypes } from './types';
import { ValidationManager } from './validationManager/ValidationManager';
export declare class LogStoreClient implements Disposable {
    private readonly streamrClient;
    private readonly authentication;
    private readonly logStoreRegistry;
    private readonly logStoreQueries;
    private readonly logStoreClientEventEmitter;
    private readonly logStoreQueryManager;
    private readonly logstoreTokenManager;
    private readonly logStoreNodeManager;
    private readonly validationManager;
    private readonly strictLogStoreClientConfig;
    private readonly tlsnManager;
    private readonly systemMessages$;
    private readonly streamObservableFactory;
    private readonly streamIdBuilder;
    constructor(streamrClient: StreamrClient, logStoreClientConfig?: LogStoreClientConfig, 
    /** @internal */
    parentContainer?: import("tsyringe").DependencyContainer);
    getSigner(): Promise<Signer>;
    /**
     * Stake funds so can query
     */
    queryStake(amount: bigint, options?: {
        usd: boolean;
    }, overrides?: Overrides): Promise<import("ethers").ContractReceipt>;
    /**
     * Performs a query of stored historical data.
     *
     * @category Important
     *
     * @param streamDefinition - the stream partition for which data should be resent
     * @param input - defines the kind of query that should be performed
     * @param onMessage - callback will be invoked for each message retrieved
     * @returns a {@link MessageStream} that provides an alternative way of iterating messages. Rejects if the stream is
     * not stored (i.e. is not assigned to a storage node).
     */
    query(streamDefinition: StreamDefinition, input: QueryInput, onMessage?: MessageListener, options?: QueryOptions): Promise<LogStoreMessageStream>;
    getQueryBalance(): Promise<bigint>;
    getQueryBalanceOf(address: EthereumAddress): Promise<bigint>;
    createQueryUrl(nodeUrl: string, streamDefinition: StreamDefinition, type: QueryType | string, queryParams: HttpApiQueryDict): Promise<string>;
    apiAuth(): Promise<{
        user: EthereumAddress;
        password: string;
        token: string;
    }>;
    /**
     * Add a stream to LogStore.
     */
    stakeOrCreateStore(streamIdOrPath: string, amount: bigint, overrides?: Overrides): Promise<ContractTransaction>;
    /**
     * Checks whether a stream is assigned to a storage node.
     */
    isLogStoreStream(streamIdOrPath: string): Promise<boolean>;
    /**
     * Gets all streams assigned to a storage node.
     *
     * @returns a list of {@link Stream} as well as `blockNumber` of result (i.e. blockchain state)
     */
    getLogStoreStreams(): Promise<{
        streams: Stream[];
        blockNumber: number;
    }>;
    /**
     * Retrieves the balance of a stream.
     *
     * @param {string} streamIdOrPath - The ID or path of the stream.
     *
     * @return {Promise<bigint>} The balance of the stream as a bigint.
     */
    getStreamBalance(streamIdOrPath: string): Promise<bigint>;
    /**
     * Retrieves the balance of the store for this account.
     */
    getStoreBalance(): Promise<bigint>;
    /**
     * Sets the validation schema to validate new messages before storing on LogStore nodes.
     */
    setValidationSchema(...params: Parameters<ValidationManager['setValidationSchema']>): Promise<void>;
    /**
     * Removes the validation schema from a stream.
     */
    removeValidationSchema(...params: Parameters<ValidationManager['removeValidationSchema']>): Promise<void>;
    /**
     * Retrieves the validation schema for a stream.
     */
    getValidationSchema(...params: Parameters<ValidationManager['getValidationSchema']>): Promise<Schema | null>;
    /**
     * Extracts the validation schema for a stream from the stream metadata object.
     */
    getValidationSchemaFromStreamMetadata(...params: Parameters<ValidationManager['getValidationSchemaFromStreamMetadata']>): Promise<Schema | null>;
    /**
     * Creates important observables for a stream.
     *
     * An observable is a stream of data that an observer can subscribe to.
     * It provides a way to handle or execute tasks whenever an event occurs, such as metadata updates.
     *
     * @param params - Parameters for stream observable creation
     * @returns A dictionary of observables that provides an alternative way to process stream data.
     */
    createStreamObservable(...params: Parameters<StreamObservableFactory['createStreamObservable']>): {
        metadataObservable: import("rxjs").Observable<import("streamr-client").StreamMetadata>;
    };
    /**
     * Verifies a TLSN proof.
     *
     * @param proof - the TLSN proof to verify
     * @param notaryPublicKey - the public key of the notary
     * @returns the verified proof
     */
    verifyTlsProof(proof: string, notaryPublicKey: string): Promise<string>;
    getBalance(): Promise<bigint>;
    /**
     * Mints tokens for the account, using MATIC. Tokens are used to stake for querying and storage.
     */
    mint(weiAmountToMint: bigint, overrides?: Overrides): Promise<ContractTransaction>;
    /**
     * Gets price data for the token.
     */
    getPrice(): Promise<bigint>;
    /**
     * Gets conversion rate for the token, from/to multiple amount types.
     */
    convert({ amount, from, to, }: {
        amount: string;
        from: AmountTypes;
        to: AmountTypes;
    }): Promise<string>;
    getConfig(): LogStoreClientConfig;
    /**
     * Get the URL for a LogStore Node, given the address, using on-chain data.
     * Not all nodes are guaranteed to expose a Gateway.
     *
     * @param address
     */
    getNodeUrl(address: string): Promise<string | null>;
    /**
     * Get node URLs list for LogStore, ordered by latency.
     */
    getNodeUrlsByLatency(): Promise<string[]>;
    /**
     * This observable emits lists of nodes information from the LogStore, ordered by latency, as heartbeat messages are received.
     */
    get nodesHeartbeatInformationListObservable(): import("rxjs").Observable<{
        nodeAddress: EthereumAddress;
        publishDate: Date;
        latency: number;
    }[]>;
    /**
     * Adds an event listener to the client.
     * @param eventName - event name, see {@link LogStoreClientEvents} for options
     * @param listener - the callback function
     */
    on<T extends keyof LogStoreClientEvents>(eventName: T, listener: LogStoreClientEvents[T]): void;
    /**
     * Adds an event listener to the client that is invoked only once.
     * @param eventName - event name, see {@link LogStoreClientEvents} for options
     * @param listener - the callback function
     */
    once<T extends keyof LogStoreClientEvents>(eventName: T, listener: LogStoreClientEvents[T]): void;
    /**
     * Removes an event listener from the client.
     * @param eventName - event name, see {@link LogStoreClientEvents} for options
     * @param listener - the callback function to remove
     */
    off<T extends keyof LogStoreClientEvents>(eventName: T, listener: LogStoreClientEvents[T]): void;
    /**
     * Destroys an instance of a {@link LogStoreClient} by disconnecting from peers, clearing any pending tasks, and
     * freeing up resources. This should be called once a user is done with the instance.
     *
     * @remarks As the name implies, the client instance (or any streams or subscriptions returned by it) should _not_
     * be used after calling this method.
     */
    destroy(): void;
    /**
     * Part of the Explicit Resource Management feature from ECMAScript. Polyfilled to work from ES3 onwards.
     * Supports the `using` statement in TypeScript 5.2+.
     *
     * @see {link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html#using-declarations-and-explicit-resource-management}
     */
    [Symbol.dispose](): void;
}
