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 DisputesClient {
    type Options = BaseClientOptions;
    interface RequestOptions extends BaseRequestOptions {
    }
}
/**
 * A Dispute is a chargeback a customer files against a payment through their bank, or an inquiry that may become one. It carries the disputed payment, a deadline to respond, your evidence, and the outcome once the processor rules.
 *
 * Use the Disputes API to list disputes, edit the evidence packet while a dispute is still contestable, and submit it for review, or accept a chargeback you don't want to contest.
 */
export declare class DisputesClient {
    protected readonly _options: NormalizedClientOptionsWithAuth<DisputesClient.Options>;
    constructor(options?: DisputesClient.Options);
    /**
     * Lists the disputes across the accounts you can read.
     *
     * @param {Whop.ListDisputesRequest} request
     * @param {DisputesClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Whop.BadRequestError}
     * @throws {@link Whop.UnauthorizedError}
     * @throws {@link Whop.ForbiddenError}
     * @throws {@link errors.WhopError}
     * @throws {@link errors.WhopTimeoutError}
     *
     * @example
     *     await client.disputes.list()
     */
    list(request?: Whop.ListDisputesRequest, requestOptions?: DisputesClient.RequestOptions): Promise<core.Page<Whop.Dispute, Whop.ListDisputesResponse>>;
    /**
     * Totals up the same disputes the list returns, so you can build status tabs and totals without paging through them.
     *
     * @param {Whop.SummaryDisputesRequest} request
     * @param {DisputesClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Whop.BadRequestError}
     * @throws {@link Whop.UnauthorizedError}
     * @throws {@link errors.WhopError}
     * @throws {@link errors.WhopTimeoutError}
     *
     * @example
     *     await client.disputes.summary()
     */
    summary(request?: Whop.SummaryDisputesRequest, requestOptions?: DisputesClient.RequestOptions): core.HttpResponsePromise<Whop.SummaryDisputesResponse>;
    private __summary;
    /**
     * Retrieves a single dispute.
     *
     * @param {Whop.RetrieveDisputesRequest} request
     * @param {DisputesClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Whop.UnauthorizedError}
     * @throws {@link Whop.NotFoundError}
     * @throws {@link errors.WhopError}
     * @throws {@link errors.WhopTimeoutError}
     *
     * @example
     *     await client.disputes.retrieve({
     *         id: "id"
     *     })
     */
    retrieve(request: Whop.RetrieveDisputesRequest, requestOptions?: DisputesClient.RequestOptions): core.HttpResponsePromise<Whop.Dispute>;
    private __retrieve;
    /**
     * Edits a dispute's evidence while it is still editable. When the evidence is ready, send it to the payment processor with `POST /disputes/:id/submit`.
     *
     * @param {Whop.UpdateDisputesRequest} request
     * @param {DisputesClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Whop.BadRequestError}
     * @throws {@link Whop.UnauthorizedError}
     * @throws {@link Whop.NotFoundError}
     * @throws {@link errors.WhopError}
     * @throws {@link errors.WhopTimeoutError}
     *
     * @example
     *     await client.disputes.update({
     *         id: "id"
     *     })
     */
    update(request: Whop.UpdateDisputesRequest, requestOptions?: DisputesClient.RequestOptions): core.HttpResponsePromise<Whop.Dispute>;
    private __update;
    /**
     * Accepts a chargeback, conceding it to the customer instead of contesting it. The payment processor closes the dispute as `lost`. This is final — the dispute cannot be contested afterwards. Only a dispute whose `acceptable` is true can be accepted.
     *
     * @param {Whop.AcceptDisputesRequest} request
     * @param {DisputesClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Whop.BadRequestError}
     * @throws {@link Whop.UnauthorizedError}
     * @throws {@link Whop.ForbiddenError}
     * @throws {@link Whop.NotFoundError}
     * @throws {@link Whop.ConflictError}
     * @throws {@link errors.WhopError}
     * @throws {@link errors.WhopTimeoutError}
     *
     * @example
     *     await client.disputes.accept({
     *         id: "id"
     *     })
     */
    accept(request: Whop.AcceptDisputesRequest, requestOptions?: DisputesClient.RequestOptions): core.HttpResponsePromise<Whop.Dispute>;
    private __accept;
    /**
     * Sends a dispute's evidence to the payment processor. This is final — it cannot be edited or sent again.
     *
     * @param {Whop.SubmitDisputesRequest} request
     * @param {DisputesClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Whop.BadRequestError}
     * @throws {@link Whop.UnauthorizedError}
     * @throws {@link Whop.NotFoundError}
     * @throws {@link Whop.ConflictError}
     * @throws {@link errors.WhopError}
     * @throws {@link errors.WhopTimeoutError}
     *
     * @example
     *     await client.disputes.submit({
     *         id: "id"
     *     })
     */
    submit(request: Whop.SubmitDisputesRequest, requestOptions?: DisputesClient.RequestOptions): core.HttpResponsePromise<Whop.Dispute>;
    private __submit;
    /**
     * Replaces the full set of uploaded evidence documents on a dispute, beyond the four fixed evidence slots. Prefer `PATCH /disputes/:id` with `evidence.documents`, which does the same replace alongside every other evidence field in one call.
     *
     * @param {Whop.UploadEvidenceDisputesRequest} request
     * @param {DisputesClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Whop.BadRequestError}
     * @throws {@link Whop.UnauthorizedError}
     * @throws {@link Whop.NotFoundError}
     * @throws {@link Whop.ConflictError}
     * @throws {@link errors.WhopError}
     * @throws {@link errors.WhopTimeoutError}
     *
     * @example
     *     await client.disputes.uploadEvidence({
     *         id: "id",
     *         documents: [{
     *                 document_type: "return_policy"
     *             }]
     *     })
     */
    uploadEvidence(request: Whop.UploadEvidenceDisputesRequest, requestOptions?: DisputesClient.RequestOptions): core.HttpResponsePromise<Whop.Dispute>;
    private __uploadEvidence;
}