import { type Libp2p, type Libp2pOptions } from 'libp2p';
import { Signer } from 'ethers';
import { StorageObject, FileInfo, ComputeJob, ComputeOutput, ComputeAlgorithm, ComputeAsset, ComputeEnvironment, ProviderInitialize, ProviderComputeInitializeResults, UserCustomParameters, ComputeResourceRequest, ComputeJobMetadata, PolicyServerInitializeCommand, PolicyServerPassthroughCommand, dockerRegistryAuth, DownloadResponse, ComputeResultStream, NodeStatus, NodeComputeJob, PersistentStorageAccessList, PersistentStorageBucket, PersistentStorageCreateBucketRequest, PersistentStorageDeleteFileResponse, PersistentStorageFileEntry, PersistentStorageObject, PersistentStorageUpdateBucketResponse, OceanNode, SignerOrAuthTokenOrSignature } from '../../@types/index.js';
import { NodeLogEntry } from '../../@types/Provider.js';
import { type DDO, type ValidateMetadata } from '@oceanprotocol/ddo-js';
import { CID } from 'multiformats/cid';
export declare const OCEAN_P2P_PROTOCOL = "/ocean/nodes/1.0.0";
/**
 * Optional request payload sent as LP frames after the command JSON; ends with an empty LP frame.
 * This mirrors ocean-node's `p2pStreamBody` mechanism introduced for true streaming uploads.
 */
export type P2PRequestBodyStream = AsyncIterable<Uint8Array | ArrayBufferView | string>;
export interface P2PConfig {
    /**
     * Bootstrap peer multiaddrs for DHT peer discovery.
     * Required when dialing bare peer IDs; defaults to Ocean Protocol's
     * public bootstrap nodes. Ignored if `libp2p.peerDiscovery` is set.
     */
    bootstrapPeers?: string[];
    /** Timeout per dial + stream operation in ms. Default: 10000 */
    dialTimeout?: number;
    /** Max retry attempts on connection errors. Default: 5 */
    maxRetries?: number;
    /** Base delay between retries in ms. Default: 1000 */
    retryDelay?: number;
    /**
     * Timeout for DHT peer lookup when dialing a bare peer ID, in ms. Default: 60000.
     * Intentionally separate from dialTimeout — DHT resolution needs more time than
     * a direct dial. Once a peer is found and connected, subsequent calls skip this.
     */
    dhtLookupTimeout?: number;
    /**
     * Enable TCP transport in addition to WebSockets. Default: false.
     * Required in Node.js/Electron environments to reach nodes over plain TCP.
     * Do NOT enable in browser builds — TCP is not available in browsers.
     */
    enableTcp?: boolean;
    /**
     * Full libp2p node configuration. Fields provided here override ocean.js
     * defaults (transports, encrypters, services, connectionManager, etc.).
     * Unset fields keep ocean.js defaults.
     */
    libp2p?: Partial<Libp2pOptions>;
    /** Additional roles to be marked. Will be used in the future */
    additionalRoles?: string[];
}
export declare class P2pProvider {
    private p2pConfig;
    private libp2pNode;
    /**
     * Configure the internal libp2p node used for P2P transport.
     * Call this once before making P2P requests, e.g.:
     *   ProviderInstance.setupP2P({ bootstrapPeers: ['/ip4/1.2.3.4/tcp/9000/ws/p2p/16Uiu2...'] })
     *
     * Required when using bare peer IDs as nodeUri — the bootstrap peers
     * provide DHT entry points so the peer can be located.
     */
    setupP2P(config: P2PConfig): Promise<void>;
    getMultiaddrFromPeerId(peerId: string): Promise<string>;
    /** Returns the underlying libp2p node instance, or null if P2P is not initialized. */
    getLibp2pNode(): Libp2p | null;
    /** Returns all peers known to the peerStore (discovered via bootstrap, DHT, or connections). */
    getDiscoveredNodes(): Promise<Array<{
        peerId: string;
        multiaddrs: string[];
    }>>;
    private bufToHex;
    private handleProtocolCommands;
    private getOrCreateLibp2pNode;
    private toUint8Array;
    cidFromRawString(data: string): Promise<CID<unknown, 85, 18, 1>>;
    getProvidersForString(input: string, signal?: AbortSignal): Promise<Array<{
        id: string;
        multiaddrs: any[];
    }>>;
    private isDialable;
    /**
     * True when the multiaddr does not include the relay `p2p-circuit` protocol segment.
     * (Direct / transport paths omit it; relay paths contain `/p2p-circuit/...`.)
     */
    private isNotP2PCircuit;
    private peerIdFromMultiaddr;
    private getConnection;
    private getNodePublicKey;
    protected getAuthorization(s: SignerOrAuthTokenOrSignature): string;
    private getSignedCommandParams;
    private dialAndStream;
    private sendP2pCommand;
    /**
     * Returns node status via P2P STATUS command.
     * @param {string} nodeUri - multiaddr of the node
     */
    getEndpoints(nodeUri: OceanNode): Promise<any>;
    getNodeStatus(nodeUri: OceanNode, signal?: AbortSignal): Promise<NodeStatus>;
    getNodeJobs(nodeUri: OceanNode, fromTimestamp?: number, signal?: AbortSignal): Promise<NodeComputeJob[]>;
    /**
     * Get current nonce from the node via P2P.
     */
    getNonce(nodeUri: OceanNode, consumerAddress: string, signal?: AbortSignal): Promise<number>;
    /**
     * Encrypt data via P2P ENCRYPT command.
     */
    encrypt(data: any, chainId: number, nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, _policyServer?: any, signal?: AbortSignal): Promise<string>;
    /**
     * Get file details for a given DID and service ID via P2P.
     */
    checkDidFiles(did: string, serviceId: string, nodeUri: OceanNode, withChecksum?: boolean, signal?: AbortSignal): Promise<FileInfo[]>;
    /**
     * Get File details via P2P.
     */
    getFileInfo(file: StorageObject, nodeUri: OceanNode, withChecksum?: boolean, signal?: AbortSignal): Promise<FileInfo[]>;
    /**
     * Returns compute environments via P2P.
     */
    getComputeEnvironments(nodeUri: OceanNode, signal?: AbortSignal): Promise<ComputeEnvironment[]>;
    /**
     * Initializes the provider for a service (download) request via P2P.
     */
    initialize(did: string, serviceId: string, fileIndex: number, consumerAddress: string, nodeUri: OceanNode, signal?: AbortSignal, userCustomParameters?: UserCustomParameters, computeEnv?: string, validUntil?: number): Promise<ProviderInitialize>;
    /**
     * Initializes compute request via P2P. No auth required -- the node only
     * validates parameters and applies rate limits.
     */
    initializeCompute(assets: ComputeAsset[], algorithm: ComputeAlgorithm, computeEnv: string, token: string, validUntil: number, nodeUri: OceanNode, consumerAddress: string, resources: ComputeResourceRequest[], chainId: number, policyServer?: any, signal?: AbortSignal, queueMaxWaitTime?: number, dockerRegistryAuthData?: dockerRegistryAuth, output?: ComputeOutput): Promise<ProviderComputeInitializeResults>;
    /**
     * Sends a DOWNLOAD command to the peer via P2P, reads the binary stream
     * directly from the lpStream, and returns a DownloadResponse.
     * The node decrypts the service file and streams raw file data back.
     */
    getDownloadUrl(did: string, serviceId: string, fileIndex: number, transferTxId: string, nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, policyServer?: any, userCustomParameters?: UserCustomParameters): Promise<DownloadResponse>;
    /**
     * Start a paid compute job via P2P.
     */
    computeStart(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, computeEnv: string, datasets: ComputeAsset[], algorithm: ComputeAlgorithm, maxJobDuration: number, token: string, resources: ComputeResourceRequest[], chainId: number, metadata?: ComputeJobMetadata, additionalViewers?: string[], output?: ComputeOutput, policyServer?: any, signal?: AbortSignal, queueMaxWaitTime?: number, dockerRegistryAuth?: dockerRegistryAuth, outputBucketId?: string): Promise<ComputeJob | ComputeJob[]>;
    /**
     * Start a free compute job via P2P.
     */
    freeComputeStart(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, computeEnv: string, datasets: ComputeAsset[], algorithm: ComputeAlgorithm, resources?: ComputeResourceRequest[], metadata?: ComputeJobMetadata, additionalViewers?: string[], output?: ComputeOutput, policyServer?: any, signal?: AbortSignal, queueMaxWaitTime?: number, dockerRegistryAuth?: dockerRegistryAuth, outputBucketId?: string): Promise<ComputeJob | ComputeJob[]>;
    /**
     * Get streamable compute logs via P2P. Returns an async generator of Uint8Array chunks.
     */
    computeStreamableLogs(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, jobId: string, signal?: AbortSignal): Promise<any>;
    /**
     * Stop a compute job via P2P.
     */
    computeStop(jobId: string, nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, agreementId?: string, signal?: AbortSignal): Promise<ComputeJob | ComputeJob[]>;
    /**
     * Get compute status via P2P.
     */
    computeStatus(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, jobId?: string, agreementId?: string, signal?: AbortSignal): Promise<ComputeJob | ComputeJob[]>;
    /**
     * Get compute result as an async generator of Uint8Array chunks via P2P.
     * Supports resumable downloads via `offset` (byte position to resume from).
     */
    getComputeResult(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, jobId: string, index: number, offset?: number): Promise<ComputeResultStream>;
    getComputeResultUrl(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, jobId: string, index: number): Promise<string>;
    /**
     * Generate an auth token via P2P (auto-signs with Signer).
     */
    generateAuthToken(consumer: Signer, nodeUri: OceanNode, signal?: AbortSignal): Promise<string>;
    /**
     * Generate an auth token from a pre-signed request (no Signer needed).
     */
    generateSignedAuthToken(address: string, signature: string, nonce: string, nodeUri: OceanNode, validUntil?: number, signal?: AbortSignal): Promise<string>;
    /**
     * Resolve a DDO by DID via P2P GET_DDO command.
     */
    resolveDdo(nodeUri: OceanNode, did: string, signal?: AbortSignal): Promise<any>;
    /**
     * Validate a DDO via P2P VALIDATE_DDO command.
     */
    validateDdo(nodeUri: OceanNode, ddo: DDO, signerOrAuthToken: SignerOrAuthTokenOrSignature, signal?: AbortSignal): Promise<ValidateMetadata>;
    /**
     * Invalidate an auth token via P2P.
     */
    invalidateAuthToken(consumer: Signer, token: string, nodeUri: OceanNode, signal?: AbortSignal): Promise<{
        success: boolean;
    }>;
    /**
     * Check if a P2P node is reachable by calling STATUS.
     */
    isValidProvider(nodeUri: OceanNode, signal?: AbortSignal): Promise<boolean>;
    /**
     * PolicyServer passthrough via P2P.
     */
    PolicyServerPassthrough(nodeUri: OceanNode, request: PolicyServerPassthroughCommand, signal?: AbortSignal): Promise<any>;
    /**
     * Initialize Policy Server verification via P2P.
     */
    initializePSVerification(nodeUri: OceanNode, request: PolicyServerInitializeCommand, signal?: AbortSignal): Promise<any>;
    /**
     * Download node logs via P2P.
     */
    downloadNodeLogs(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, startTime: string, endTime: string, maxLogs?: number, moduleName?: string, level?: string, page?: number, signal?: AbortSignal): Promise<NodeLogEntry[]>;
    /**
     * Fetch node configuration via P2P. Accepts a pre-signed payload —
     * the caller is responsible for nonce retrieval and signing.
     */
    fetchConfig(nodeUri: OceanNode, payload: Record<string, any>): Promise<any>;
    /**
     * Push node configuration via P2P. Accepts a pre-signed payload —
     * the caller is responsible for nonce retrieval and signing.
     */
    pushConfig(nodeUri: OceanNode, payload: Record<string, any>): Promise<any>;
    createPersistentStorageBucket(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, payload: PersistentStorageCreateBucketRequest, signal?: AbortSignal): Promise<{
        bucketId: string;
        owner: string;
        accessList: PersistentStorageAccessList[];
        label?: string | null;
    }>;
    updatePersistentStorageBucket(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, bucketId: string, label: string | null, signal?: AbortSignal): Promise<PersistentStorageUpdateBucketResponse>;
    getPersistentStorageBuckets(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, owner: string, signal?: AbortSignal): Promise<PersistentStorageBucket[]>;
    listPersistentStorageFiles(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, bucketId: string, signal?: AbortSignal): Promise<PersistentStorageFileEntry[]>;
    getPersistentStorageFileObject(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, bucketId: string, fileName: string, signal?: AbortSignal): Promise<PersistentStorageObject>;
    uploadPersistentStorageFile(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, bucketId: string, fileName: string, content: P2PRequestBodyStream, signal?: AbortSignal): Promise<PersistentStorageFileEntry>;
    deletePersistentStorageFile(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, bucketId: string, fileName: string, signal?: AbortSignal): Promise<PersistentStorageDeleteFileResponse>;
}