import type { CheckNullifiersResponse, CompactScanResponse, FetchByCommitmentRequest, FetchByCommitmentResponse, ChallengeResponse, CheckUsernameResponse, DeleteUserDataResponse, MerkleProofResponse, MerkleRootResponse, MerkleTreeResponse, PreRegisterKeyResponse, PrepareMergeRequest, ClientProductOpen, FinalizeClientNotesRequest, FinalizeClientNotesResponse, PrepareClientJperpOpenRequest, PrepareClientJperpOpenResponse, SubmitClientJperpOpenResponse, PrepareClientProductOpenRequest, PrepareClientProductOpenResponse, SubmitClientProductOpenResponse, PrepareClientSwapRequest, PrepareClientSwapResponse, SubmitClientSwapRequest, SubmitClientSwapResponse, PrepareTransferRequest, PrepareTransferResponse, SubmitTransferResponse, PrepareMergeResponse, PrepareWithdrawRequest, PrepareWithdrawResponse, PrivateSwapRequest, PrivateSwapResponse, PrivateTransferRequest, PrivateTransferResponse, QueryNotesRequest, QueryNotesResponse, RegisterRequest, RegisterResponse, RestoreRequest, RestoreResponse, RetryPolicy, SaveEncryptedNoteRequest, SaveEncryptedNoteResponse, SubmitMergeRequest, SubmitMergeResponse, SubmitSpendRequest, SubmitWithdrawResponse, VeiloPublicKeyResponse, WithdrawRequest, WithdrawResponse } from "./types.js";
import { type InternalRelayerClientOptions } from "./internal-config.js";
import type { ClosePositionRequest, ClosePositionResponse, MergePositionsRequest, MergePositionsResponse, OpenPositionRequest, OpenPositionResponse } from "../positions/types.js";
import type { JperpCancelTriggerRequest, JperpCancelTriggerResponse, JperpCloseRequest, JperpDecreaseResponse, JperpOpenRequest, JperpOpenResponse, JperpRecoverNativeRequest, JperpRecoverNativeResponse, JperpRecoverSeedRequest, JperpRecoverSeedResponse, JperpReissueRequest, JperpReissueResponse, JperpSetTpslRequest, JperpUpdateTpslRequest } from "../perps/types.js";
import type { PredictionOpenRequest, PredictionOpenResponse, PredictionReissueRequest, PredictionReissueResponse } from "../predictions/types.js";
export declare class VeiloRelayerClient {
    private readonly transport;
    private readonly relayerPubKey;
    constructor(config?: InternalRelayerClientOptions, retry?: Partial<RetryPolicy>);
    /** Update the auth token (e.g. after register/restore). */
    setAuthToken(token: string): void;
    private encryptPayload;
    /** Request a signature challenge for wallet authentication. */
    getChallenge(walletPublicKey: string): Promise<ChallengeResponse>;
    /** Register a new account with a signed challenge. Returns a JWT auth token. */
    register(data: RegisterRequest): Promise<RegisterResponse>;
    /** Restore an existing account using a signed challenge. Returns a JWT auth token. */
    restore(data: RestoreRequest): Promise<RestoreResponse>;
    /** Check whether a username is available for registration. */
    checkUsername(username: string): Promise<CheckUsernameResponse>;
    /** Look up a user's Veilo public key by username or wallet public key. */
    getVeiloPublicKey(params: {
        username: string;
        publicKey?: never;
    } | {
        publicKey: string;
        username?: never;
    }): Promise<VeiloPublicKeyResponse>;
    /**
     * Provision (or retrieve) the Veilo spend key paired with a Solana address.
     * Public and idempotent; the response contains public key material only.
     */
    preRegisterKey(solanaAddress: string): Promise<PreRegisterKeyResponse>;
    /** Save an encrypted note to the relayer's database. */
    saveEncryptedNote(data: SaveEncryptedNoteRequest): Promise<SaveEncryptedNoteResponse>;
    /** Query encrypted notes for the authenticated user. Requires auth token. */
    queryEncryptedNotes(params?: QueryNotesRequest): Promise<QueryNotesResponse>;
    /** Delete all stored data for the authenticated user. Requires auth token. */
    /**
     * One page of the public compact-note feed.
     *
     * Unauthenticated by design: rows carry only ciphertext and a one-byte view
     * tag, so scanning reveals nothing without the recipient's key. The feed
     * excludes spent notes and any note already claimed by a wallet.
     */
    compactScan(params?: {
        limit?: number;
        cursor?: string;
    }): Promise<CompactScanResponse>;
    /** Look up stored notes by commitment. Max 50 per request. */
    fetchNotesByCommitment(data: FetchByCommitmentRequest): Promise<FetchByCommitmentResponse>;
    /**
     * Ask which of these nullifiers the relayer has seen spent.
     *
     * Caller must respect MAX_NULLIFIERS_PER_CHECK; `checkNullifiersSpent` in
     * notes/spent.ts does the chunking. Unauthenticated: a nullifier reveals
     * nothing about ownership on its own.
     */
    checkNullifiers(nullifiers: string[]): Promise<CheckNullifiersResponse>;
    deleteUserData(): Promise<DeleteUserDataResponse>;
    /** Fetch the current Merkle root for a pool, optionally filtered by mint and tree ID. */
    getMerkleRoot(mintAddress?: string, treeId?: number): Promise<MerkleRootResponse>;
    /**
     * Inclusion proofs for up to 50 commitments. A commitment the relayer has
     * not indexed yet comes back with `found: false` rather than an error.
     */
    getMerkleProof(commitments: string[], mintAddress?: string, treeId?: number): Promise<MerkleProofResponse>;
    /** Fetch the full Merkle tree (all leaves) for a pool. */
    getMerkleTree(mintAddress?: string, treeId?: number): Promise<MerkleTreeResponse>;
    /** Submit an encrypted withdrawal request to the relayer. Not retried on failure. */
    submitWithdraw(data: WithdrawRequest): Promise<WithdrawResponse>;
    /** Submit an encrypted private transfer request. Not retried on failure. */
    submitPrivateTransfer(data: PrivateTransferRequest): Promise<PrivateTransferResponse>;
    /** Ask what a withdrawal proof must commit to. */
    prepareWithdraw(data: PrepareWithdrawRequest): Promise<PrepareWithdrawResponse>;
    /** Quote a client-proved product open (prediction, card or MetaDAO commit). */
    prepareClientProductOpen(product: ClientProductOpen, data: PrepareClientProductOpenRequest): Promise<PrepareClientProductOpenResponse>;
    /** Submit a locally generated product-open proof against its quote. */
    submitClientProductOpenProof(product: ClientProductOpen, data: SubmitSpendRequest): Promise<SubmitClientProductOpenResponse>;
    /** Quote a client-proved Jupiter-perps open, pinning the trade the proof cannot bind. */
    prepareClientJperpOpen(data: PrepareClientJperpOpenRequest): Promise<PrepareClientJperpOpenResponse>;
    /** Submit a locally generated perp-open proof against its quote. */
    submitClientJperpOpenProof(data: SubmitSpendRequest): Promise<SubmitClientJperpOpenResponse>;
    /** Quote a client-proved swap: prices it and returns what the proof must commit to. */
    prepareClientSwap(data: PrepareClientSwapRequest): Promise<PrepareClientSwapResponse>;
    /** Submit a locally generated swap proof against its quote. */
    submitClientSwapProof(data: SubmitClientSwapRequest): Promise<SubmitClientSwapResponse>;
    /** Ask what a private-transfer proof must commit to. */
    prepareTransfer(data: PrepareTransferRequest): Promise<PrepareTransferResponse>;
    /** Submit a locally generated private-transfer proof against its quote. */
    submitTransferProof(data: SubmitSpendRequest): Promise<SubmitTransferResponse>;
    /** After a client-proved spend lands, re-save its note blobs with the real leaf index. */
    finalizeClientNotes(data: FinalizeClientNotesRequest): Promise<FinalizeClientNotesResponse>;
    /** Submit a locally generated withdrawal proof against its quote. */
    submitWithdrawProof(data: SubmitSpendRequest): Promise<SubmitWithdrawResponse>;
    /**
     * Quote one consolidation round.
     *
     * Pass the WHOLE note set for the mint, not a pair: the relayer plans the
     * round's pairings so its round count matches the one the spend path uses.
     */
    prepareMergeRound(data: PrepareMergeRequest): Promise<PrepareMergeResponse>;
    /**
     * Submit a proved consolidation round.
     *
     * May land partially — check `data.replanRequired` before assuming the round
     * completed.
     */
    submitMergeRound(data: SubmitMergeRequest): Promise<SubmitMergeResponse>;
    /** Submit an encrypted private swap request. Not retried on failure. */
    submitPrivateSwap(data: PrivateSwapRequest): Promise<PrivateSwapResponse>;
    submitOpenPosition(data: OpenPositionRequest): Promise<OpenPositionResponse>;
    submitClosePosition(data: ClosePositionRequest): Promise<ClosePositionResponse>;
    submitMergePositions(data: MergePositionsRequest): Promise<MergePositionsResponse>;
    submitJperpOpen(data: JperpOpenRequest): Promise<JperpOpenResponse>;
    submitJperpClose(data: JperpCloseRequest): Promise<JperpDecreaseResponse>;
    submitJperpSetTpsl(data: JperpSetTpslRequest): Promise<JperpDecreaseResponse>;
    submitJperpUpdateTpsl(data: JperpUpdateTpslRequest): Promise<JperpDecreaseResponse>;
    submitJperpCancelTrigger(data: JperpCancelTriggerRequest): Promise<JperpCancelTriggerResponse>;
    submitJperpReissue(data: JperpReissueRequest): Promise<JperpReissueResponse>;
    submitJperpRecoverSeed(data: JperpRecoverSeedRequest): Promise<JperpRecoverSeedResponse>;
    submitJperpRecoverNative(data: JperpRecoverNativeRequest): Promise<JperpRecoverNativeResponse>;
    submitPredictionOpen(data: PredictionOpenRequest): Promise<PredictionOpenResponse>;
    submitPredictionReissue(data: PredictionReissueRequest): Promise<PredictionReissueResponse>;
    private submitEncrypted;
}