import type * as Whop from "../index.mjs";
export interface ResolutionCenterCase {
    /** The account the case was filed against. */
    account: Whop.AccountSummary | null;
    /** The amount in question, in whole units of `currency`. */
    amount: number;
    available_actions: ResolutionCenterCase.AvailableActions.Item[];
    /** The customer who opened the case. */
    buyer: Whop.ResolutionBuyer;
    /** When the case was opened, as an ISO 8601 timestamp. */
    created_at: string;
    /** Three-letter ISO currency code of the amount. */
    currency: string | null;
    /** Whether the customer has appealed a decision on this case. */
    customer_appealed: boolean;
    /** Whether Whop is involved — either reviewing the case, or waiting on the side named by `status` for something it asked for while reviewing. */
    escalated: boolean;
    /** Resolution center case ID, prefixed `reso_`. */
    id: string;
    line_items: Whop.ReceiptLineItem[];
    /** Who prevailed on the claim. `null` until the case closes. Read `refund` for whether any money actually moved. */
    outcome: ResolutionCenterCase.Outcome | null;
    /** The payment the case was opened against. */
    payment: Whop.ResolutionPayment;
    /** The product the payment was for, prefixed `prod_`. */
    product_id: string | null;
    /** What the customer says went wrong. Shares the `/disputes` vocabulary, so a case that later becomes a chargeback reports the same complaint. */
    reason: ResolutionCenterCase.Reason;
    /** Whether money moved and off whose balance: `none`, `merchant`, or `platform` (Whop refunded the customer and the merchant kept the funds). Independent of `outcome` — a case the merchant won can still carry a platform refund. `null` while the case is open, and on older closed cases that predate this being recorded. */
    refund: ResolutionCenterCase.Refund | null;
    /** When the next response is due, as an ISO 8601 timestamp. */
    response_due_at: string | null;
    /** Who the case is waiting on. `awaiting_merchant` and `awaiting_customer` name the side that owes a response, `under_review` means Whop is deciding, and `closed` means it is settled — read `outcome` for how. */
    status: ResolutionCenterCase.Status;
    /** When the case was last changed, as an ISO 8601 timestamp. */
    updated_at: string;
    /** The variant the payment was made on, prefixed `plan_`. */
    variant_id: string | null;
}
export declare namespace ResolutionCenterCase {
    type AvailableActions = AvailableActions.Item[];
    namespace AvailableActions {
        /** What you can do to this case right now, named for the endpoint that does it. Resolved for the calling credential, so a merchant and a customer reading the same case see their own options. */
        const Item: {
            readonly Accept: "accept";
            readonly Deny: "deny";
            readonly RequestInfo: "request_info";
            readonly Reply: "reply";
            readonly Appeal: "appeal";
            readonly Withdraw: "withdraw";
        };
        type Item = (typeof Item)[keyof typeof Item];
    }
    /** Who prevailed on the claim. `null` until the case closes. Read `refund` for whether any money actually moved. */
    const Outcome: {
        readonly CustomerWon: "customer_won";
        readonly MerchantWon: "merchant_won";
        readonly Withdrawn: "withdrawn";
    };
    type Outcome = (typeof Outcome)[keyof typeof Outcome];
    /** What the customer says went wrong. Shares the `/disputes` vocabulary, so a case that later becomes a chargeback reports the same complaint. */
    const Reason: {
        readonly Fraudulent: "fraudulent";
        readonly ProductNotReceived: "product_not_received";
        readonly NotAsDescribed: "not_as_described";
        readonly ProductUnacceptable: "product_unacceptable";
        readonly SubscriptionCanceled: "subscription_canceled";
    };
    type Reason = (typeof Reason)[keyof typeof Reason];
    /** Whether money moved and off whose balance: `none`, `merchant`, or `platform` (Whop refunded the customer and the merchant kept the funds). Independent of `outcome` — a case the merchant won can still carry a platform refund. `null` while the case is open, and on older closed cases that predate this being recorded. */
    const Refund: {
        readonly None: "none";
        readonly Merchant: "merchant";
        readonly Platform: "platform";
    };
    type Refund = (typeof Refund)[keyof typeof Refund];
    /** Who the case is waiting on. `awaiting_merchant` and `awaiting_customer` name the side that owes a response, `under_review` means Whop is deciding, and `closed` means it is settled — read `outcome` for how. */
    const Status: {
        readonly AwaitingMerchant: "awaiting_merchant";
        readonly AwaitingCustomer: "awaiting_customer";
        readonly UnderReview: "under_review";
        readonly Closed: "closed";
    };
    type Status = (typeof Status)[keyof typeof Status];
}