import type { BaseClientOptions, BaseRequestOptions } from "../../../../BaseClient.mjs";
import { type NormalizedClientOptionsWithAuth } from "../../../../BaseClient.mjs";
import * as core from "../../../../core/index.mjs";
import * as Whop from "../../../index.mjs";
export declare namespace ResolutionCenterCasesClient {
    type Options = BaseClientOptions;
    interface RequestOptions extends BaseRequestOptions {
    }
}
/**
 * A Resolution Center Case is opened by a buyer when something is wrong with a purchase, such as an unwanted renewal, an item that never arrived, or a charge they don't recognize. It is the step before a chargeback: the buyer and merchant work it out directly, and Whop decides the case if they can't.
 *
 * Use the Resolution Center Cases API from either side: as the buyer, open, reply to, appeal, or withdraw a case; as the merchant, accept it (refunding the payment), deny it, or ask the buyer for more information.
 */
export declare class ResolutionCenterCasesClient {
    protected readonly _options: NormalizedClientOptionsWithAuth<ResolutionCenterCasesClient.Options>;
    constructor(options?: ResolutionCenterCasesClient.Options);
    /**
     * Lists resolution center cases. Without `account_id` you get every case you can read — the ones you opened as a buyer and every account you are a team member of; the filters narrow that list.
     *
     * @param {Whop.ListResolutionCenterCasesRequest} request
     * @param {ResolutionCenterCasesClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Whop.UnauthorizedError}
     * @throws {@link Whop.ForbiddenError}
     * @throws {@link Whop.NotFoundError}
     * @throws {@link errors.WhopError}
     * @throws {@link errors.WhopTimeoutError}
     *
     * @example
     *     await client.resolutionCenterCases.list()
     */
    list(request?: Whop.ListResolutionCenterCasesRequest, requestOptions?: ResolutionCenterCasesClient.RequestOptions): Promise<core.Page<Whop.ResolutionCenterCase, Whop.ListResolutionCenterCasesResponse>>;
    /**
     * Opens a case, as the customer, against one of your own payments. Provide the payment (`receipt_id`), the `reason`, and a `message`.
     *
     * @param {Whop.CreateResolutionCenterCasesRequest} request
     * @param {ResolutionCenterCasesClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Whop.UnauthorizedError}
     * @throws {@link Whop.ConflictError}
     * @throws {@link errors.WhopError}
     * @throws {@link errors.WhopTimeoutError}
     *
     * @example
     *     await client.resolutionCenterCases.create({
     *         message: "The mobile detailer never showed up for the Ceramic Coating appointment.",
     *         reason: "fraudulent",
     *         receipt_id: "pay_xxxxxxxxxxxxxx"
     *     })
     */
    create(request: Whop.CreateResolutionCenterCasesRequest, requestOptions?: ResolutionCenterCasesClient.RequestOptions): core.HttpResponsePromise<Whop.ResolutionCenterCase>;
    private __create;
    /**
     * Aggregates the same cases `GET /resolution_center_cases` lists, using the same filters. Use it to build status tabs and issue filters without paging the whole list.
     *
     * @param {Whop.SummaryResolutionCenterCasesRequest} request
     * @param {ResolutionCenterCasesClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Whop.BadRequestError}
     * @throws {@link Whop.UnauthorizedError}
     * @throws {@link errors.WhopError}
     * @throws {@link errors.WhopTimeoutError}
     *
     * @example
     *     await client.resolutionCenterCases.summary()
     */
    summary(request?: Whop.SummaryResolutionCenterCasesRequest, requestOptions?: ResolutionCenterCasesClient.RequestOptions): core.HttpResponsePromise<Whop.SummaryResolutionCenterCasesResponse>;
    private __summary;
    /**
     * Retrieves a single resolution center case with its full event timeline.
     *
     * @param {Whop.RetrieveResolutionCenterCasesRequest} request
     * @param {ResolutionCenterCasesClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Whop.UnauthorizedError}
     * @throws {@link Whop.NotFoundError}
     * @throws {@link errors.WhopError}
     * @throws {@link errors.WhopTimeoutError}
     *
     * @example
     *     await client.resolutionCenterCases.retrieve({
     *         id: "id"
     *     })
     */
    retrieve(request: Whop.RetrieveResolutionCenterCasesRequest, requestOptions?: ResolutionCenterCasesClient.RequestOptions): core.HttpResponsePromise<Whop.ResolutionCenterCase>;
    private __retrieve;
    /**
     * Accepts the case in the customer's favor, as the merchant: refunds the payment in full and closes the case.
     *
     * @param {Whop.AcceptResolutionCenterCasesRequest} request
     * @param {ResolutionCenterCasesClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Whop.UnauthorizedError}
     * @throws {@link Whop.ForbiddenError}
     * @throws {@link Whop.ConflictError}
     * @throws {@link errors.WhopError}
     * @throws {@link errors.WhopTimeoutError}
     *
     * @example
     *     await client.resolutionCenterCases.accept({
     *         id: "id"
     *     })
     */
    accept(request: Whop.AcceptResolutionCenterCasesRequest, requestOptions?: ResolutionCenterCasesClient.RequestOptions): core.HttpResponsePromise<Whop.ResolutionCenterCase>;
    private __accept;
    /**
     * Appeals a decision, as the customer, on a case that closed in the merchant's favor. Escalates the case to Whop for platform review. A case can be appealed once, within 7 days of the decision.
     *
     * @param {Whop.AppealResolutionCenterCasesRequest} request
     * @param {ResolutionCenterCasesClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Whop.UnauthorizedError}
     * @throws {@link Whop.ConflictError}
     * @throws {@link errors.WhopError}
     * @throws {@link errors.WhopTimeoutError}
     *
     * @example
     *     await client.resolutionCenterCases.appeal({
     *         id: "id",
     *         message: "The coating is already flaking on the hood two weeks later."
     *     })
     */
    appeal(request: Whop.AppealResolutionCenterCasesRequest, requestOptions?: ResolutionCenterCasesClient.RequestOptions): core.HttpResponsePromise<Whop.ResolutionCenterCase>;
    private __appeal;
    /**
     * Denies the case, as the merchant: rejects the claim and closes the case with no refund.
     *
     * @param {Whop.DenyResolutionCenterCasesRequest} request
     * @param {ResolutionCenterCasesClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Whop.UnauthorizedError}
     * @throws {@link Whop.ConflictError}
     * @throws {@link errors.WhopError}
     * @throws {@link errors.WhopTimeoutError}
     *
     * @example
     *     await client.resolutionCenterCases.deny({
     *         id: "id",
     *         message: "The ceramic coating was applied and the vehicle was collected on 2026-01-05."
     *     })
     */
    deny(request: Whop.DenyResolutionCenterCasesRequest, requestOptions?: ResolutionCenterCasesClient.RequestOptions): core.HttpResponsePromise<Whop.ResolutionCenterCase>;
    private __deny;
    /**
     * Lists the case timeline, newest first. Events the viewer is not allowed to see are omitted — a customer reads the customer-visible timeline, the merchant reads the full one.
     *
     * @param {Whop.EventsResolutionCenterCasesRequest} request
     * @param {ResolutionCenterCasesClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Whop.UnauthorizedError}
     * @throws {@link Whop.NotFoundError}
     * @throws {@link errors.WhopError}
     * @throws {@link errors.WhopTimeoutError}
     *
     * @example
     *     await client.resolutionCenterCases.events({
     *         id: "id"
     *     })
     */
    events(request: Whop.EventsResolutionCenterCasesRequest, requestOptions?: ResolutionCenterCasesClient.RequestOptions): Promise<core.Page<Whop.ResolutionEvent, Whop.EventsResolutionCenterCasesResponse>>;
    /**
     * Replies to an open request for information on the case. As the merchant this answers Whop's request (valid while the case awaits your information); as the customer it provides the information requested from you. The actor is resolved from the credential.
     *
     * @param {Whop.ReplyResolutionCenterCasesRequest} request
     * @param {ResolutionCenterCasesClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Whop.UnauthorizedError}
     * @throws {@link Whop.ConflictError}
     * @throws {@link errors.WhopError}
     * @throws {@link errors.WhopTimeoutError}
     *
     * @example
     *     await client.resolutionCenterCases.reply({
     *         id: "id",
     *         message: "Here are the before and after photos from the Burnet Rd bay."
     *     })
     */
    reply(request: Whop.ReplyResolutionCenterCasesRequest, requestOptions?: ResolutionCenterCasesClient.RequestOptions): core.HttpResponsePromise<Whop.ResolutionCenterCase>;
    private __reply;
    /**
     * Asks the customer for more information, as the merchant. Allowed up to 3 times per case before you must accept or deny it.
     *
     * @param {Whop.RequestInfoResolutionCenterCasesRequest} request
     * @param {ResolutionCenterCasesClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Whop.UnauthorizedError}
     * @throws {@link Whop.ConflictError}
     * @throws {@link errors.WhopError}
     * @throws {@link errors.WhopTimeoutError}
     *
     * @example
     *     await client.resolutionCenterCases.requestInfo({
     *         id: "id"
     *     })
     */
    requestInfo(request: Whop.RequestInfoResolutionCenterCasesRequest, requestOptions?: ResolutionCenterCasesClient.RequestOptions): core.HttpResponsePromise<Whop.ResolutionCenterCase>;
    private __requestInfo;
    /**
     * Withdraws (cancels) a case you opened, as the customer. Only possible while the case is still open.
     *
     * @param {Whop.WithdrawResolutionCenterCasesRequest} request
     * @param {ResolutionCenterCasesClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Whop.UnauthorizedError}
     * @throws {@link Whop.ConflictError}
     * @throws {@link errors.WhopError}
     * @throws {@link errors.WhopTimeoutError}
     *
     * @example
     *     await client.resolutionCenterCases.withdraw({
     *         id: "id"
     *     })
     */
    withdraw(request: Whop.WithdrawResolutionCenterCasesRequest, requestOptions?: ResolutionCenterCasesClient.RequestOptions): core.HttpResponsePromise<Whop.ResolutionCenterCase>;
    private __withdraw;
}