import { v } from "@dicedhq/core/validation";
import { type Hex } from "viem";
import type { BaseClient } from "../client/base.js";
import { type SignatureType } from "../core/eip712.js";
import type { MarketApi } from "./market.js";
export declare class OrderApi {
    private readonly client;
    private readonly market;
    constructor(client: BaseClient, market: MarketApi);
    /**
     * Get an order by ID
     */
    getOrder(id: string): Promise<OpenOrder>;
    /**
     * List active orders for a given market
     */
    listOrders(params: ListOrderParams): Promise<OpenOrder[]>;
    /**
     * Check if an order is eligible or scoring for Rewards purposes
     */
    checkOrderRewardScoring(id: string): Promise<boolean>;
    /**
     * Create an order
     */
    createOrder(params: CreateOrderParams): Promise<SignedOrder>;
    /**
     * Post an order to the order book
     */
    postOrder({ order, kind }: {
        order: SignedOrder;
        kind: OrderKind;
    }): Promise<OrderResponse>;
    /**
     * Create and post an order in one step
     */
    createAndPostOrder(params: CreateOrderAndPostParams): Promise<OrderResponse>;
    /**
     * Cancel an order
     */
    cancelOrder(id: string): Promise<CancelResponse>;
    /**
     * Cancel multiple orders
     */
    cancelOrders(orderIds: string[]): Promise<CancelResponse>;
    /**
     * Cancel all orders
     */
    cancelAllOrders(): Promise<CancelResponse>;
    private getNonce;
    /**
     * Generate a cryptographically secure random salt for order uniqueness
     */
    private generateSalt;
    private calculateOrderAmounts;
}
declare const ListOrderSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
    readonly orderId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
    readonly marketId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.NonEmptyAction<string, "Value is required and cannot be empty">]>;
    readonly assetId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
}, undefined>, v.MetadataAction<{
    orderId?: string | undefined;
    marketId: string;
    assetId?: string | undefined;
}, {
    readonly title: "ListOrderParams";
}>]>;
declare const CreateOrderSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
    readonly tokenId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.NonEmptyAction<string, "Value is required and cannot be empty">]>;
    readonly price: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, "Value must be positive">, v.CheckAction<number, "Value must be positive">]>;
    readonly size: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, "Value must be positive">, v.CheckAction<number, "Value must be positive">]>;
    readonly side: v.PicklistSchema<["BUY", "SELL"], undefined>;
    readonly expiration: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
    readonly taker: v.UnionSchema<[v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.StartsWithAction<string, "0x", undefined>]>, v.LiteralSchema<"anyone", undefined>], undefined>;
    /** Optional funder address (e.g., a Safe contract). If provided, this becomes the maker address. */
    readonly funderAddress: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.StartsWithAction<string, "0x", undefined>]>, undefined>;
    /** Signature type. Defaults to "eoa". Use "poly-gnosis-safe" for Safe wallet signing. */
    readonly signatureType: v.OptionalSchema<v.PicklistSchema<["eoa", "poly-proxy", "poly-gnosis-safe"], undefined>, undefined>;
}, undefined>, v.MetadataAction<{
    tokenId: string;
    price: number;
    size: number;
    side: "BUY" | "SELL";
    expiration: number;
    taker: string;
    funderAddress?: string | undefined;
    signatureType?: "eoa" | "poly-gnosis-safe" | "poly-proxy" | undefined;
}, {
    readonly title: "CreateOrderParams";
}>]>;
export type ListOrderParams = v.InferInput<typeof ListOrderSchema>;
export type CreateOrderParams = v.InferInput<typeof CreateOrderSchema>;
export type Order = {
    salt: string;
    maker: Hex;
    signer: Hex;
    taker: Hex;
    tokenId: string;
    makerAmount: string;
    takerAmount: string;
    expiration: string;
    nonce: string;
    feeRateBps: string;
    side: OrderSide;
    signatureType: SignatureType;
};
export type SignedOrder = Order & {
    signature: string;
};
export type OpenOrder = {
    id: string;
    market: string;
    asset_id: string;
    owner: string;
    side: OrderSide;
    size: string;
    original_size: string;
    price: string;
    type: OrderKind;
    fee_rate_bps: string;
    status: string;
    created_at?: string;
    last_update?: string;
    outcome?: string;
    expiration?: string;
    maker_address?: string;
    associate_trades?: AssociateTrade[];
};
export type OrderSide = "BUY" | "SELL";
export type OrderKind = "GTC" | "FOK" | "GTD" | "FAK";
export type OrderResponse = {
    success: boolean;
    errorMsg?: string;
    orderID?: string;
    transactionsHashes?: string[];
};
export type CreateOrderAndPostParams = {
    kind: OrderKind;
    order: CreateOrderParams;
};
export type CancelResponse = {
    success: boolean;
    errorMsg?: string;
};
export type AssociateTrade = {
    id: string;
    order_id: string;
    market: string;
    asset_id: string;
    side: OrderSide;
    size: string;
    fee_rate_bps: string;
    price: string;
    status: string;
    match_time?: string;
    last_update?: string;
    outcome?: string;
    owner?: string;
    maker_address?: string;
    transaction_hash?: string;
};
export {};
//# sourceMappingURL=order.d.ts.map