import { Keypair, Transaction, type PublicKey, type TransactionInstruction } from "@solana/web3.js";
import type { ClientContext } from "../../context";
import type { SignedOrder, CloseOrderStatusParams, BidOrderParams, AskOrderParams, OrderStatus as ProgramOrderStatus } from "../../program/types";
import { type OrderBookId, type PubkeyStr } from "../../shared";
import { LimitOrderEnvelope, TriggerOrderEnvelope } from "../../program/envelope";
import { type UserSnapshotBalance, type UserSnapshotOrder, type UserOrderFillsResponse } from "./wire";
export interface CancelBody {
    order_hash: string;
    maker: PubkeyStr;
    signature: string;
}
export declare function cancelBodyFromBase58(orderHash: string, maker: PubkeyStr, signatureBase58: string): CancelBody;
export declare function cancelBodySigned(orderHash: string, maker: PubkeyStr, keypair: Keypair): CancelBody;
export interface CancelAllBody {
    user_pubkey: PubkeyStr;
    orderbook_id: OrderBookId;
    signature: string;
    timestamp: number;
    salt: string;
}
export declare function cancelAllBodyFromBase58(userPubkey: PubkeyStr, orderbookId: OrderBookId, timestamp: number, salt: string, signatureBase58: string): CancelAllBody;
export declare function cancelAllBodySigned(userPubkey: PubkeyStr, orderbookId: OrderBookId, timestamp: number, salt: string, keypair: Keypair): CancelAllBody;
export interface CancelTriggerBody {
    trigger_order_id: string;
    maker: PubkeyStr;
    signature: string;
}
export declare function cancelTriggerBodyFromBase58(triggerOrderId: string, maker: PubkeyStr, signatureBase58: string): CancelTriggerBody;
export declare function cancelTriggerBodySigned(triggerOrderId: string, maker: PubkeyStr, keypair: Keypair): CancelTriggerBody;
export interface FillInfo {
    counterparty: PubkeyStr;
    counterparty_order_hash: string;
    fill_amount: string;
    price: string;
    is_maker: boolean;
}
export interface SubmitOrderResponse {
    order_hash: string;
    remaining: string;
    filled: string;
    fills: FillInfo[];
}
export interface CancelSuccess {
    order_hash: string;
    remaining: string;
}
export interface CancelAllSuccess {
    cancelled_order_hashes: string[];
    count: number;
    user_pubkey: PubkeyStr;
    orderbook_id: OrderBookId;
    message: string;
}
export interface TriggerOrderResponse {
    trigger_order_id: string;
    order_hash: string;
}
export interface CancelTriggerSuccess {
    trigger_order_id: string;
}
export interface UserOrdersResponse {
    user_pubkey: PubkeyStr;
    orders: UserSnapshotOrder[];
    balances: UserSnapshotBalance[];
    next_cursor?: string;
    has_more: boolean;
}
export declare class Orders {
    private readonly client;
    constructor(client: ClientContext);
    statusPda(orderHash: Buffer): PublicKey;
    noncePda(user: PublicKey): PublicKey;
    limitOrder(): LimitOrderEnvelope;
    triggerOrder(): TriggerOrderEnvelope;
    generateCancelAllSalt(): string;
    submit(request: object): Promise<SubmitOrderResponse>;
    cancel(body: CancelBody): Promise<CancelSuccess>;
    cancelAll(body: CancelAllBody): Promise<CancelAllSuccess>;
    submitTrigger(request: object): Promise<TriggerOrderResponse>;
    cancelTrigger(body: CancelTriggerBody): Promise<CancelTriggerSuccess>;
    /**
     * Fetch the authenticated user's open orders. Wallet is resolved
     * server-side from the auth cookie, so no parameter is required.
     */
    getUserOrders(limit?: number, cursor?: string): Promise<UserOrdersResponse>;
    /**
     * Same as {@link getUserOrders}, but uses the supplied `cookieHeader` for
     * this call instead of the SDK's process-wide cookie store. For
     * server-side cookie forwarding (SSR / route handlers).
     */
    getUserOrdersWithCookies(limit: number | undefined, cursor: string | undefined, cookieHeader: string): Promise<UserOrdersResponse>;
    /**
     * Fetch the authenticated user's filled orders with nested fill events.
     * Wallet is resolved server-side from the auth cookie.
     */
    getUserOrderFills(marketPubkey?: string, limit?: number, cursor?: string): Promise<UserOrderFillsResponse>;
    /**
     * Same as {@link getUserOrderFills}, but uses the supplied `cookieHeader`
     * for this call instead of the SDK's process-wide cookie store. For
     * server-side cookie forwarding (SSR / route handlers).
     */
    getUserOrderFillsWithCookies(marketPubkey: string | undefined, limit: number | undefined, cursor: string | undefined, cookieHeader: string): Promise<UserOrderFillsResponse>;
    /**
     * Public variant of {@link getUserOrderFills}. Takes the user's wallet
     * via the URL path (`GET /api/users/{wallet}/order-fills`) and requires
     * no auth.
     */
    getUserOrderFillsByWallet(walletAddress: string, marketPubkey?: string, limit?: number, cursor?: string): Promise<UserOrderFillsResponse>;
    cancelOrderSigned(orderHash: string, maker: PubkeyStr): Promise<CancelSuccess>;
    cancelAllSigned(userPubkey: PubkeyStr, timestamp: number, salt: string, orderbookId?: OrderBookId): Promise<CancelAllSuccess>;
    cancelTriggerSigned(triggerOrderId: string, maker: PubkeyStr): Promise<CancelTriggerSuccess>;
    cancelOrderIx(operator: PublicKey, market: PublicKey, order: SignedOrder): TransactionInstruction;
    incrementNonceIx(user: PublicKey): TransactionInstruction;
    closeOrderStatusIx(params: CloseOrderStatusParams): TransactionInstruction;
    cancelOrderTx(operator: PublicKey, market: PublicKey, order: SignedOrder): Transaction;
    incrementNonceTx(user: PublicKey): Transaction;
    closeOrderStatusTx(params: CloseOrderStatusParams): Transaction;
    createBidOrder(params: BidOrderParams): Omit<SignedOrder, "signature">;
    createAskOrder(params: AskOrderParams): Omit<SignedOrder, "signature">;
    createSignedBidOrder(params: BidOrderParams, signer: Keypair): SignedOrder;
    createSignedAskOrder(params: AskOrderParams, signer: Keypair): SignedOrder;
    hashOrder(order: SignedOrder): Buffer;
    signOrder(order: SignedOrder, signer: Keypair): Buffer;
    signFullOrder(order: Omit<SignedOrder, "signature">, signer: Keypair): SignedOrder;
    getStatus(orderHash: Buffer): Promise<ProgramOrderStatus | null>;
    getNonce(user: PublicKey): Promise<bigint>;
    currentNonce(user: PublicKey): Promise<number>;
}
//# sourceMappingURL=client.d.ts.map