/**
 * Shape of the `notifications.claim` label block consumed by the claim flow.
 * Mirrors the typed labels so callers can reason about the toast copy.
 */
export type ClaimNotificationLabels = {
    pendingTitle: string;
    pendingMessage: string;
    submittedTitle: string;
    submittedMessage: string;
    successTitle: string;
    successMessage: string;
    partialTitle: string;
    partialMessage: (errorReason?: string) => string;
    failedTitle: string;
    failedMessage: (errorReason?: string) => string;
    missingOutcomeMessage: string;
};
/** Terminal lifecycle summary forwarded to `onClaimResult`. */
export type ClaimLifecycleResult = {
    allConfirmed: boolean;
    anyFailed: boolean;
    errorMessage: string | null;
};
/** A single claim request keyed by `claimKey`. */
export type ClaimWinningsInput<TPayload = void> = {
    /** Stable identifier for the position being claimed (e.g. `marketId`). */
    claimKey: string;
    /** Winning venue-market-outcome ids to redeem. */
    winningOutcomeIds: string[];
    /** Opaque payload forwarded verbatim to a caller-provided `onClaim`. */
    payload?: TPayload;
};
export type UseClaimWinningsOptions<TPayload = void> = {
    /**
     * Caller-owned claim handler. When provided, the hook delegates the actual
     * redeem to this callback and toasts a simple pending → success/failure
     * lifecycle (no WS lifecycle tracking). Partners who own the claim flow pass
     * this; omit it to let the hook drive the internal redeem mutation.
     */
    onClaim?: (payload: TPayload) => Promise<void> | void;
    /**
     * Fired once per redeem when its WS lifecycle reaches terminal. Only fired on
     * the internal claim path (i.e. when `onClaim` is omitted).
     */
    onClaimResult?: (claimKey: string, lifecycle: ClaimLifecycleResult) => void;
    /**
     * Fired when the redeem mutation itself rejects (transport error, validation
     * error, or all legs ineligible/rejected at submit time). The redeem never
     * enters the WS lifecycle in these cases, so `onClaimResult` does NOT fire.
     */
    onClaimSubmitError?: (claimKey: string, error: Error) => void;
    /**
     * Caller-owned spinner map. When provided, it fully replaces the hook's
     * lifecycle-derived spinner state for display purposes (mirrors the legacy
     * `claimingPositionKeys ?? internal` behavior).
     */
    externalClaimingKeys?: Record<string, boolean>;
};
export type UseClaimWinningsResult<TPayload = void> = {
    /** Start a claim for a single position. Resolves once the submit settles. */
    claim: (input: ClaimWinningsInput<TPayload>) => Promise<void>;
    /** Map of claim key → in-flight flag, suitable to pass to a row renderer. */
    claimingKeys: Record<string, boolean>;
    /** Whether a given claim key is currently in-flight (submit or lifecycle). */
    isClaiming: (claimKey: string) => boolean;
};
/**
 * Encapsulates the full "claim winnings" (redeem) lifecycle so multiple
 * surfaces (the profile positions list, the resolved market trade panel) can
 * share one implementation instead of duplicating the redeem → WS lifecycle →
 * toast → cache-invalidation orchestration.
 *
 * The flow has two paths:
 *  - **Internal** (`onClaim` omitted): submit via the redeem mutation, bucket
 *    the response legs (submitted / confirmed / ineligible / rejected), track
 *    EVM async legs through their WS lifecycle, and toast pending → submitted →
 *    success/partial/failed.
 *  - **Delegated** (`onClaim` provided): the caller performs the redeem; the
 *    hook only toasts pending → success/failure.
 *
 * Both paths invalidate balances, positions, the claimable count, the activity
 * feed, and the current-user query so dependent UI refreshes.
 */
export declare function useClaimWinnings<TPayload = void>(options?: UseClaimWinningsOptions<TPayload>): UseClaimWinningsResult<TPayload>;
