import { a as operations, i as components, n as PaystackWebhookEvent, o as paths, r as Webhooks, t as PaymentNotificationWebhookEvent } from "./webhooks-bUJrY0tj.mjs";
import * as _$openapi_fetch0 from "openapi-fetch";
import { Client, MaybeOptionalInit } from "openapi-fetch";

//#region src/client.d.ts
type PaystackPaths = paths;
type PaystackClient = Client<PaystackPaths>;
interface PaystackClientOptions {
  secretKey: string;
  baseUrl?: string;
  fetch?: typeof fetch;
  headers?: Record<string, string>;
  /** Abort the request if it takes longer than this many milliseconds. */
  timeoutMs?: number;
  /** Automatically retry transient failures (defaults to safe/idempotent methods only). */
  retry?: PaystackRetryOptions;
  /**
   * Adds an idempotency key header automatically on POST requests (useful for safe retries).
   * If you already set an Idempotency-Key header per request, this will not override it.
   */
  idempotencyKey?: string | (() => string);
  /** Header name to use for idempotency. Default: 'Idempotency-Key' */
  idempotencyHeader?: string;
}
interface PaystackRetryOptions {
  /** Number of retries after the initial attempt. Default: 2 */
  retries?: number;
  /** Minimum backoff delay. Default: 250 */
  minDelayMs?: number;
  /** Maximum backoff delay. Default: 2000 */
  maxDelayMs?: number;
  /** HTTP statuses to retry. Default: [408, 429, 500, 502, 503, 504] */
  retryOnStatuses?: number[];
  /** HTTP methods to retry. Default: ['GET','HEAD','OPTIONS'] */
  retryOnMethods?: string[];
}
declare function createPaystackClient(options: PaystackClientOptions): PaystackClient;
//#endregion
//#region src/errors.d.ts
declare const DEFAULT_REQUEST_ID_HEADERS: readonly ["x-paystack-request-id", "x-request-id"];
/**
 * Extracts a Paystack Request ID from response headers.
 */
declare function getPaystackRequestId(headers: Headers | HeadersInit): string | undefined;
type PaystackErrorType = "api_error" | "validation_error" | "processor_error" | (string & {});
interface PaystackErrorOptions {
  message: string;
  code?: string;
  type?: PaystackErrorType;
  status?: number;
  requestId?: string;
  meta?: Record<string, unknown>;
  /** Parsed Paystack response envelope or transport payload used to create this error. */
  raw?: unknown;
  /** Alias for raw, kept for callers that prefer body-oriented naming. */
  body?: unknown;
  /** Original transport/openapi-fetch error, when one exists. */
  cause?: unknown;
}
/**
 * Standard Paystack API Error
 */
declare class PaystackError extends Error {
  /** The machine-readable error code */
  readonly code?: string;
  /** The error type (e.g., api_error, validation_error, processor_error) */
  readonly type?: string;
  /** The HTTP status code */
  readonly status?: number;
  /** The request ID for debugging with Paystack support */
  readonly requestId?: string;
  /** Additional metadata from the error response */
  readonly meta?: Record<string, unknown>;
  /** Parsed Paystack response envelope or transport payload used to create this error. */
  readonly raw?: unknown;
  /** Alias for raw, kept for callers that prefer body-oriented naming. */
  readonly body?: unknown;
  constructor(options: PaystackErrorOptions);
  /**
   * Helper to determine if the error is a processor-level issue
   * (e.g., insufficient funds, card declined)
   */
  isProcessorError(): boolean;
  /**
   * Helper to determine if the error is due to invalid request parameters
   */
  isValidationError(): boolean;
}
/**
 * @deprecated Use PaystackError
 */
declare const PaystackApiError: typeof PaystackError;
/**
 * @deprecated Use PaystackError
 */
declare function isPaystackApiError(value: unknown): value is PaystackError;
//#endregion
//#region src/response.d.ts
/**
 * Base structure of a Paystack API response body
 */
interface PaystackRawResponse<T = unknown> {
  status: boolean;
  message: string;
  data: T;
  code?: string;
  type?: PaystackErrorType;
  meta?: Record<string, unknown>;
  errorCodeMappingNotFound?: boolean;
}
/**
 * Enhanced response wrapper for the Paystack SDK.
 * Provides .unwrap() and .data helpers for elegant error handling.
 */
declare class PaystackResponse<T> {
  /** The raw JSON data returned in the response body */
  readonly raw: PaystackRawResponse<T> | undefined;
  /** The error object if the request failed (from openapi-fetch) */
  readonly error: unknown;
  /** The raw fetch Response object */
  readonly response: Response;
  constructor(/** The raw JSON data returned in the response body */

  raw: PaystackRawResponse<T> | undefined, /** The error object if the request failed (from openapi-fetch) */

  error: unknown, /** The raw fetch Response object */

  response: Response);
  /**
   * The success indicator from the Paystack API body.
   */
  get status(): boolean;
  /**
   * The message from the Paystack API body.
   */
  get message(): string;
  /**
   * Helper to automatically check the Paystack status and throw a descriptive
   * PaystackError if it fails. Returns the unwrapped 'data' payload on success.
   *
   * @throws {PaystackError} if status is false or an HTTP error occurred.
   */
  unwrap(): T;
  /**
   * A convenience getter that returns the data payload after unwrapping.
   * Use this when you are confident the request succeeded or want to catch at a higher level.
   *
   * @throws {PaystackError} if status is false.
   */
  get data(): T;
}
declare function assertOk<T>(result: PaystackResponse<T>): T;
declare function toPaystackApiError<T>(result: PaystackResponse<T>): PaystackError | undefined;
//#endregion
//#region src/operations.d.ts
type InitArg<T, HasPath = false> = HasPath extends true ? [init?: Partial<T>] : undefined extends T ? [init?: Exclude<T, undefined>] : [init: T];
/**
 * List Domains
 *
 * Lists all registered domains on your integration. Returns an empty array if no domains have been added.
 */
declare function applePay_listDomain(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/apple-pay/domain"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Register Domain
 *
 * Register a top-level domain or subdomain for your Apple Pay integration.
 *
 * > This endpoint can only be called with one domain or subdomain at a time.
 *
 */
declare function applePay_registerDomain(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/apple-pay/domain"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Unregister Domain
 *
 * Unregister a top-level domain or subdomain previously used for your Apple
 * Pay integration.
 *
 */
declare function applePay_unregisterDomain(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/apple-pay/domain"], "delete">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Balance
 *
 * Fetch the available balance on your integration
 */
declare function balance_fetch(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/balance"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Balance Ledger
 *
 * Fetch all pay-ins and pay-outs that occured on your integration
 */
declare function balance_ledger(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/balance/ledger"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * List Banks
 *
 * Get a list of all supported banks and their properties
 */
declare function bank_list(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/bank"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Resolve Account Number
 *
 * Resolve an account number to confirm the name associated with it
 */
declare function bank_resolveAccountNumber(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/bank/resolve"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Validate Bank Account
 *
 * Confirm the authenticity of a customer's account number before sending money
 */
declare function bank_validateAccountNumber(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/bank/validate"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * List Charges in a Batch
 *
 * This endpoint retrieves the charges associated with a specified batch code
 *
 * @param id_or_code An ID or code for the batch whose charges you want to retrieve.
 */
declare function bulkCharge_charges(client: PaystackClient, id_or_code: string, ...init: InitArg<MaybeOptionalInit<paths["/bulkcharge/{id_or_code}/charges"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Bulk Charge Batch
 *
 * This endpoint retrieves a specific batch code. It also returns useful information on its progress by
 * way of the `total_charges` and `pending_charges` attributes.
 *
 *
 * @param id_or_code An ID or code for the charge whose batches you want to retrieve.
 */
declare function bulkCharge_fetch(client: PaystackClient, id_or_code: string, ...init: InitArg<MaybeOptionalInit<paths["/bulkcharge/{id_or_code}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Initiate Bulk Charge
 *
 * Charge multiple customers in batches
 */
declare function bulkCharge_initiate(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/bulkcharge"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * List Bulk Charge Batches
 *
 * List all bulk charge batches.
 */
declare function bulkCharge_list(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/bulkcharge"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Pause Bulk Charge Batch
 *
 * Pause the processing of a charge batch
 *
 * @param code The batch code for the bulk charge you want to pause
 */
declare function bulkCharge_pause(client: PaystackClient, code: string, ...init: InitArg<MaybeOptionalInit<paths["/bulkcharge/pause/{code}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Resume Bulk Charge Batch
 *
 * Resume the processing of a previously paused charge batch
 *
 * @param code The batch code for the bulk charge you want to pause
 */
declare function bulkCharge_resume(client: PaystackClient, code: string, ...init: InitArg<MaybeOptionalInit<paths["/bulkcharge/resume/{code}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Requery Transaction
 *
 * Check the status of a charge made with Capitec Pay. This endpoint should be used from your frontend application as it requires the use of your public key for request authorization.
 *
 * @param ref The transaction reference from the previously initiated charge request
 */
declare function capitecPay_requery(client: PaystackClient, ref: string, ...init: InitArg<MaybeOptionalInit<paths["/capitec-pay/requery/{ref}"], "post">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Check pending charge
 *
 * When you get `pending` as a charge status or if there was an exception when calling any of the `/charge` endpoints, wait 10 seconds or more, then make a check to see if its status has changed. Don't call too early as you may get a lot more pending than you should.
 *
 *
 * @param reference The reference of the ongoing transaction
 */
declare function charge_check(client: PaystackClient, reference: string, ...init: InitArg<MaybeOptionalInit<paths["/charge/{reference}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Create Charge
 *
 * Initiate a payment by integrating the payment channel of your choice.
 */
declare function charge_create(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/charge"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Submit Address
 *
 * Send the details of the customer's address for address verification
 */
declare function charge_submitAddress(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/charge/submit_address"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Submit Birthday
 *
 * Submit the customer's birthday when requested
 */
declare function charge_submitBirthday(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/charge/submit_birthday"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Submit OTP
 *
 * Submit OTP to complete a charge
 */
declare function charge_submitOtp(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/charge/submit_otp"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Submit Phone
 *
 * Submit phone number when requested
 */
declare function charge_submitPhone(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/charge/submit_phone"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Submit PIN
 *
 * Submit PIN to continue a charge
 */
declare function charge_submitPin(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/charge/submit_pin"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Create Customer
 *
 * Create a customer on your integration
 */
declare function customer_create(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/customer"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Deactivate Authorization
 *
 * Deactivate an authorization for any payment channel.
 */
declare function customer_deactivateAuthorization(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/customer/authorization/deactivate"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Direct Debit Activation Charge
 *
 * Trigger an activation charge on an inactive mandate on behalf of your customer
 *
 * @param id The customer ID attached to the authorization
 */
declare function customer_directDebitActivationCharge(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/customer/{id}/directdebit-activation-charge"], "put">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Customer
 *
 * Get details of a customer on your integration.
 *
 * @param email_or_code An email or customer code for the customer you want to fetch
 */
declare function customer_fetch(client: PaystackClient, email_or_code: string, ...init: InitArg<MaybeOptionalInit<paths["/customer/{email_or_code}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Mandate Authorizations
 *
 * Get the list of direct debit mandates associated with a customer
 *
 * @param id The customer ID for the authorizations to fetch
 */
declare function customer_fetchMandateAuthorizations(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/customer/{id}/directdebit-mandate-authorizations"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Initialize Authorization
 *
 * Initiate a request to create a reusable authorization code for recurring transactions
 */
declare function customer_initializeAuthorization(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/customer/authorization/initialize"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Initialize Direct Debit
 *
 * Initialize the process of linking an account to a customer for Direct Debit transactions
 *
 * @param id The ID of the customer to initialize the direct debit for
 */
declare function customer_initializeDirectDebit(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/customer/{id}/initialize-direct-debit"], "post">, true>): Promise<PaystackResponse<unknown>>;
/**
 * List Customers
 *
 * List customers available on your integration
 */
declare function customer_list(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/customer"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Set Risk Action
 *
 * Set customer's risk action by whitelisting or blacklisting the customer
 */
declare function customer_riskAction(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/customer/set_risk_action"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Update Customer
 *
 * Update a customer's details on your integration
 *
 * @param email_or_code An email or customer code for the customer you want to fetch
 */
declare function customer_update(client: PaystackClient, email_or_code: string, ...init: InitArg<MaybeOptionalInit<paths["/customer/{email_or_code}"], "put">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Validate Customer
 *
 * Validate a customer's identity
 *
 * @param customer_code Customer code
 */
declare function customer_validate(client: PaystackClient, customer_code: string, ...init: InitArg<MaybeOptionalInit<paths["/customer/{customer_code}/identification"], "post">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Verify Authorization
 *
 * Check the status of an authorization request
 *
 * @param reference The reference returned in the initialization response
 */
declare function customer_verifyAuthorization(client: PaystackClient, reference: string, ...init: InitArg<MaybeOptionalInit<paths["/customer/authorization/verify/{reference}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Split Dedicated Account Transaction
 *
 * Split a dedicated virtual account transaction with one or more accounts
 */
declare function dedicatedAccount_addSplit(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/dedicated_account/split"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Assign Dedicated Account
 *
 * With this endpoint, you can create a customer, validate the customer, and assign a DVA to the customer.
 */
declare function dedicatedAccount_assign(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/dedicated_account/assign"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Bank Providers
 *
 * Get available bank providers for a dedicated virtual account
 */
declare function dedicatedAccount_availableProviders(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/dedicated_account/available_providers"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Create Dedicated Account
 *
 * Create a dedicated virtual account for an existing customer
 */
declare function dedicatedAccount_create(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/dedicated_account"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Deactivate Dedicated Account
 *
 * Deactivate a dedicated virtual account on your integration.
 *
 * @param id ID of dedicated virtual account
 */
declare function dedicatedAccount_deactivate(client: PaystackClient, id: string, ...init: InitArg<MaybeOptionalInit<paths["/dedicated_account/{id}"], "delete">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Dedicated Account
 *
 * Get details of a dedicated virtual account on your integration.
 *
 * @param id ID of dedicated virtual account
 */
declare function dedicatedAccount_fetch(client: PaystackClient, id: string, ...init: InitArg<MaybeOptionalInit<paths["/dedicated_account/{id}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * List Dedicated Accounts
 *
 * List dedicated virtual accounts available on your integration.
 */
declare function dedicatedAccount_list(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/dedicated_account"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Remove Split from Dedicated Account
 *
 * If you've previously set up split payment for transactions on a dedicated virtual account, you can remove it with this endpoint
 */
declare function dedicatedAccount_removeSplit(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/dedicated_account/split"], "delete">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Requery Dedicated Account
 *
 * Requery Dedicated Virtual Account for new transactions
 */
declare function dedicatedAccount_requery(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/dedicated_account/requery"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * List Mandate Authorizations
 *
 * Get a list of all the direct debit mandates on your integration
 */
declare function directdebit_listMandateAuthorizations(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/directdebit/mandate-authorizations"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Trigger Activation Charge
 *
 * Trigger activation charge for specified customers
 */
declare function directdebit_triggerActivationCharge(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/directdebit/activation-charge"], "put">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Export Disputes
 *
 * Export the disputes available on your integration
 */
declare function dispute_download(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/dispute/export"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Add Evidence
 *
 * Provide evidence for a dispute
 *
 * @param id The unique identifier of the dispute
 */
declare function dispute_evidence(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/dispute/{id}/evidence"], "post">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Dispute
 *
 * Fetch a transaction dispute
 *
 * @param id The unique identifier of the dispute
 */
declare function dispute_fetch(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/dispute/{id}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * List Disputes
 *
 * List transaction disputes filed by customers
 */
declare function dispute_list(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/dispute"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Resolve Dispute
 *
 * Resolve a transaction dispute
 *
 * @param id The unique identifier of the dispute
 */
declare function dispute_resolve(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/dispute/{id}/resolve"], "put">, true>): Promise<PaystackResponse<unknown>>;
/**
 * List Transaction Disputes
 *
 * List all disputes filed for a transaction
 *
 * @param id The unique identifier of the transaction
 */
declare function dispute_transaction(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/dispute/transaction/{id}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Update Dispute
 *
 * Update a transaction dispute
 *
 * @param id The unique identifier of the dispute
 */
declare function dispute_update(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/dispute/{id}"], "put">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Upload URL
 *
 * Get the URL to upload a dispute evidence
 *
 * @param id The unique identifier of the dispute
 */
declare function dispute_uploadUrl(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/dispute/{id}/upload_url"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Payment Session Timeout
 *
 * Fetch the session timeout of a transaction
 */
declare function integration_fetchPaymentSessionTimeout(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/integration/payment_session_timeout"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Update Payment Session Timeout
 *
 * Update the session timeout of a transaction
 */
declare function integration_updatePaymentSessionTimeout(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/integration/payment_session_timeout"], "put">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Internal path for schema generation
 *
 * This path is internal and used to ensure that schemas like WebhookEvent are considered 'used' for SDK generation and linting.
 */
declare function misc_generateWebhookEventTypes(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/___internal___"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * List States (AVS)
 *
 * Get a list of states for a country for address verification
 */
declare function miscellaneous_avs(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/address_verification/states"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * List Countries
 *
 * List all supported countries on Paystack
 */
declare function miscellaneous_listCountries(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/country"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Resolve Card BIN
 *
 * Get the details of a card BIN
 *
 * @param bin The card bank identification number
 */
declare function miscellaneous_resolveCardBin(client: PaystackClient, bin: string, ...init: InitArg<MaybeOptionalInit<paths["/decision/bin/{bin}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Create Order
 *
 * Create an order for selected items
 */
declare function order_create(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/order"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Order
 *
 * Fetch the details of a previously created order
 *
 * @param id The unique identifier of the order
 */
declare function order_fetch(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/order/{id}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * List Orders
 *
 * List the previously created orders
 */
declare function order_list(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/order"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Product Orders
 *
 * Fetch all orders for a particular product
 *
 * @param id The unique identifier of the order
 */
declare function order_product(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/order/product/{id}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Validate Order
 *
 * Validate a pay for me order
 *
 * @param code The unique code of a previously created order
 */
declare function order_validate(client: PaystackClient, code: string, ...init: InitArg<MaybeOptionalInit<paths["/order/{code}/validate"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Add Products
 *
 * Add products to a previously created payment page. You can only add products to pages
 * that was created with a `product` type.
 *
 *
 * @param id
 */
declare function page_addProducts(client: PaystackClient, id: string, ...init: InitArg<MaybeOptionalInit<paths["/page/{id}/product"], "post">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Check Slug Availability
 *
 * Check if a custom slug is available for use when creating a payment page
 *
 * @param slug The custom slug to check
 */
declare function page_checkSlugAvailability(client: PaystackClient, slug: string, ...init: InitArg<MaybeOptionalInit<paths["/page/check_slug_availability/{slug}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Create Page
 *
 * Create a webpage to receive payments
 */
declare function page_create(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/page"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Page
 *
 * Get a previously created payment page
 *
 * @param id_or_slug The page ID or slug you want to fetch
 */
declare function page_fetch(client: PaystackClient, id_or_slug: string, ...init: InitArg<MaybeOptionalInit<paths["/page/{id_or_slug}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * List Pages
 *
 * List all previously created payment pages
 */
declare function page_list(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/page"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Update Page
 *
 * Update a previously created payment page
 *
 * @param id_or_slug The page ID or slug you want to fetch
 */
declare function page_update(client: PaystackClient, id_or_slug: string, ...init: InitArg<MaybeOptionalInit<paths["/page/{id_or_slug}"], "put">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Archive Payment Request
 *
 * Archive a payment request to clean up your records. An archived payment request cannot be verified and will not
 * be returned when listing all previously created payment requests.
 *
 *
 * @param id The unique identifier of a previously created payment request
 */
declare function paymentRequest_archive(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/paymentrequest/archive/{id}"], "post">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Create Payment Request
 *
 * Create a new payment request by issuing an invoice to a customer
 */
declare function paymentRequest_create(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/paymentrequest"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Payment Request
 *
 * Fetch a previously created payment request
 *
 * @param id_or_code The payment request ID or code you want to fetch
 */
declare function paymentRequest_fetch(client: PaystackClient, id_or_code: string, ...init: InitArg<MaybeOptionalInit<paths["/paymentrequest/{id_or_code}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Finalize Payment Request
 *
 * Finalise the creation of a draft payment request for a customer
 *
 * @param id The unique identifier of a draft payment request
 */
declare function paymentRequest_finalize(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/paymentrequest/finalize/{id}"], "post">, true>): Promise<PaystackResponse<unknown>>;
/**
 * List Payment Request
 *
 * List all previously created payment requests to your customers
 */
declare function paymentRequest_list(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/paymentrequest"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Send Notification
 *
 * Trigger an email reminder to a customer for a previously created payment request
 *
 * @param id The unique identifier of a previously created payment request
 */
declare function paymentRequest_notify(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/paymentrequest/notify/{id}"], "post">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Payment Request Total
 *
 * Get the metric of all pending and successful payment requests
 */
declare function paymentRequest_totals(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/paymentrequest/totals"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Update Payment Request
 *
 * Update a previously created payment request
 *
 * @param id_or_code The payment request ID or code you want to fetch
 */
declare function paymentRequest_update(client: PaystackClient, id_or_code: string, ...init: InitArg<MaybeOptionalInit<paths["/paymentrequest/{id_or_code}"], "put">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Verify Payment Request
 *
 * Verify the status of a previously created payment request
 *
 * @param id The unique identifier of a previously created payment request
 */
declare function paymentRequest_verify(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/paymentrequest/verify/{id}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Create Plan
 *
 * Create a plan for recurring payments
 */
declare function plan_create(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/plan"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Plan
 *
 * Get the details of a payment plan
 *
 * @param id_or_code The plan ID or code you want to fetch
 */
declare function plan_fetch(client: PaystackClient, id_or_code: string, ...init: InitArg<MaybeOptionalInit<paths["/plan/{id_or_code}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * List Plans
 *
 * List all recurring payment plans
 */
declare function plan_list(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/plan"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Update Plan
 *
 * Update a plan details on your integration
 *
 * @param id_or_code The plan ID or code you want to fetch
 */
declare function plan_update(client: PaystackClient, id_or_code: string, ...init: InitArg<MaybeOptionalInit<paths["/plan/{id_or_code}"], "put">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Capture Preauthorization
 *
 * Charge a preauthorized transaction upon service delivery
 */
declare function preauthorization_capture(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/preauthorization/capture"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Initialize Preauthorization
 *
 * Initialize a preauthorization transaction for a new customer
 */
declare function preauthorization_initialize(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/preauthorization/initialize"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * List Preauthorizations
 *
 * List preauthorizations carried out on your integration
 */
declare function preauthorization_list(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/preauthorization"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Release Preauthorization
 *
 * For when a customer cancels an order or you want to release the hold from their card.
 */
declare function preauthorization_release(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/preauthorization/release"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Reserve Preauthorization
 *
 * Hold an amount using an existing customer's authorization that's marked reusable.
 */
declare function preauthorization_reserve_authorization(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/preauthorization/reserve_authorization"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Verify Preauthorization
 *
 * Fetch and confirm the status of a preauthorized transaction.
 *
 * @param reference The transaction reference used to intiate the transaction
 */
declare function preauthorization_verify(client: PaystackClient, reference: string, ...init: InitArg<MaybeOptionalInit<paths["/preauthorization/verify/{reference}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Create Product
 *
 * Create a new product on your integration
 */
declare function product_create(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/product"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Delete Product
 *
 * Delete a previously created product
 *
 * @param id The unique identifier of the product
 */
declare function product_delete(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/product/{id}"], "delete">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Product
 *
 * Fetch a previously created product
 *
 * @param id The unique identifier of the product
 */
declare function product_fetch(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/product/{id}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * List Products
 *
 * List all previously created products
 */
declare function product_list(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/product"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Update product
 *
 * Update a previously created product
 *
 * @param id The unique identifier of the product
 */
declare function product_update(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/product/{id}"], "put">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Create Refund
 *
 * Initiate a refund for a previously completed transaction
 */
declare function refund_create(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/refund"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Refund
 *
 * Get a previously created refund
 *
 * @param id The identifier of the refund
 */
declare function refund_fetch(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/refund/{id}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * List Refunds
 *
 * List previously created refunds
 */
declare function refund_list(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/refund"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Retry Refund
 *
 * Retry a refund with a `needs-attention` status by providing the bank account details of a customer.
 *
 * @param id The identifier of the refund
 */
declare function refund_retry(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/refund/retry_with_customer_details/{id}"], "post">, true>): Promise<PaystackResponse<unknown>>;
/**
 * List Settlements
 *
 * List settlements made to your settlement accounts
 */
declare function settlements_fetch(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/settlement"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Settlement Transactions
 *
 * Get the transactions that make up a particular settlement
 *
 * @param id The settlement ID in which you want to fetch its transactions
 */
declare function settlements_transaction(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/settlement/{id}/transactions"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Add Subaccount to Split
 *
 * Add a subaccount to a split configuration, or update the share of an existing subaccount
 *
 * @param id The ID of the split configuration to fetch
 */
declare function split_addSubaccount(client: PaystackClient, id: string, ...init: InitArg<MaybeOptionalInit<paths["/split/{id}/subaccount/add"], "post">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Create Split
 *
 * Create a split configuration for transactions
 */
declare function split_create(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/split"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Split
 *
 * Get details of a split configuration for a transaction
 *
 * @param id The ID of the split configuration to fetch
 */
declare function split_fetch(client: PaystackClient, id: string, ...init: InitArg<MaybeOptionalInit<paths["/split/{id}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * List Splits
 *
 * List the transaction splits available on your integration
 */
declare function split_list(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/split"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Remove Subaccount from split
 *
 * Remove a subaccount from a split configuration
 *
 * @param id The ID of the split configuration to fetch
 */
declare function split_removeSubaccount(client: PaystackClient, id: string, ...init: InitArg<MaybeOptionalInit<paths["/split/{id}/subaccount/remove"], "post">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Update Split
 *
 * Update a split configuration for transactions
 *
 * @param id
 */
declare function split_update(client: PaystackClient, id: string, ...init: InitArg<MaybeOptionalInit<paths["/split/{id}"], "put">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Add Products to Storefront
 *
 * Add previously created products to a Storefront
 *
 * @param id The unique identifier of the Storefront
 */
declare function storefront_addProducts(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/storefront/{id}/product"], "post">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Create Storefront
 *
 * Create a digital shop to manage and display your products
 */
declare function storefront_create(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/storefront"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Delete Storefront
 *
 * Delete a previously created Storefront
 *
 * @param id The unique identifier of the Storefront
 */
declare function storefront_delete(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/storefront/{id}"], "delete">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Duplicate Storefront
 *
 * Duplicate a previously created Storefront
 *
 * @param id The unique identifier of the Storefront
 */
declare function storefront_duplicate(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/storefront/{id}/duplicate"], "post">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Storefront
 *
 * Get the details of a previously created Storefront
 *
 * @param id The unique identifier of the Storefront
 */
declare function storefront_fetch(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/storefront/{id}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Storefront Orders
 *
 * Fetch all orders in your Storefront
 *
 * @param id The unique identifier of the Storefront
 */
declare function storefront_fetchOrders(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/storefront/{id}/order"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * List Storefronts
 *
 * List the storefronts you previously created
 */
declare function storefront_list(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/storefront"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * List Storefront Products
 *
 * List the products in a Storefront
 *
 * @param id The unique identifier of the Storefront
 */
declare function storefront_listProducts(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/storefront/{id}/product"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Publish Storefront
 *
 * Make your Storefront publicly available
 *
 * @param id The unique identifier of the Storefront
 */
declare function storefront_publish(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/storefront/{id}/publish"], "post">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Update Storefront
 *
 * Update the details of a previously created Storefront
 *
 * @param id The unique identifier of the Storefront
 */
declare function storefront_update(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/storefront/{id}"], "put">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Verify Storefront Slug
 *
 * Verify the availability of a slug before using it for your Storefront
 *
 * @param slug The custom slug to check
 */
declare function storefront_verifySlug(client: PaystackClient, slug: string, ...init: InitArg<MaybeOptionalInit<paths["/storefront/verify/{slug}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Create Subaccount
 *
 * Create a subacount for a partner
 */
declare function subaccount_create(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/subaccount"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Subaccount
 *
 * Get details of a subaccount on your integration
 *
 * @param id_or_code The subaccount ID or code you want to fetch
 */
declare function subaccount_fetch(client: PaystackClient, id_or_code: string, ...init: InitArg<MaybeOptionalInit<paths["/subaccount/{id_or_code}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * List Subaccounts
 *
 * List subaccounts available on your integration
 */
declare function subaccount_list(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/subaccount"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Update Subaccount
 *
 * Update a subaccount details on your integration
 *
 * @param id_or_code The subaccount ID or code you want to fetch
 */
declare function subaccount_update(client: PaystackClient, id_or_code: string, ...init: InitArg<MaybeOptionalInit<paths["/subaccount/{id_or_code}"], "put">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Create Subscription
 *
 * Create a subscription a customer
 */
declare function subscription_create(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/subscription"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Disable Subscription
 *
 * Disable a subscription on your integration
 */
declare function subscription_disable(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/subscription/disable"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Enable Subscription
 *
 * Enable a subscription on your integration
 */
declare function subscription_enable(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/subscription/enable"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Subscription
 *
 * Get details of a customer's subscription
 *
 * @param id_or_code The subscription ID or code you want to fetch
 */
declare function subscription_fetch(client: PaystackClient, id_or_code: string, ...init: InitArg<MaybeOptionalInit<paths["/subscription/{id_or_code}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * List Subscriptions
 *
 * List all subscriptions available on your integration
 */
declare function subscription_list(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/subscription"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Send Update Subscription Link
 *
 * Email a customer a link for updating the card on their subscription
 *
 * @param code Subscription code
 */
declare function subscription_manageEmail(client: PaystackClient, code: string, ...init: InitArg<MaybeOptionalInit<paths["/subscription/{code}/manage/email"], "post">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Generate Update Subscription Link
 *
 * Generate a link for updating the card on a subscription
 *
 * @param code Subscription code
 */
declare function subscription_manageLink(client: PaystackClient, code: string, ...init: InitArg<MaybeOptionalInit<paths["/subscription/{code}/manage/link"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Commission Terminal
 *
 * Activate your debug device by linking it to your integration
 */
declare function terminal_commission(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/terminal/commission_device"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Decommission Terminal
 *
 * Unlink your debug device from your integration
 */
declare function terminal_decommission(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/terminal/decommission_device"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Terminal
 *
 * Get the details of a Terminal
 *
 * @param terminal_id The ID of the Terminal the event should be sent to.
 */
declare function terminal_fetch(client: PaystackClient, terminal_id: string, ...init: InitArg<MaybeOptionalInit<paths["/terminal/{terminal_id}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Event Status
 *
 * Check the status of an event sent to the Terminal
 *
 * @param terminal_id The ID of the Terminal the event should be sent to.
 * @param event_id The ID of the event that was sent to the Terminal
 */
declare function terminal_fetchEventStatus(client: PaystackClient, terminal_id: string, event_id: string, ...init: InitArg<MaybeOptionalInit<paths["/terminal/{terminal_id}/event/{event_id}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Terminal Status
 *
 * Check the availiability of a Terminal before sending an event to it
 *
 * @param terminal_id The ID of the Terminal the event should be sent to.
 */
declare function terminal_fetchTerminalStatus(client: PaystackClient, terminal_id: string, ...init: InitArg<MaybeOptionalInit<paths["/terminal/{terminal_id}/presence"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * List Terminals
 *
 * List the Terminals available on your integration
 */
declare function terminal_list(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/terminal"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Send Event
 *
 * Send an event from your application to the Paystack Terminal
 *
 * @param id The ID of the Terminal the event should be sent to.
 */
declare function terminal_sendEvent(client: PaystackClient, id: string, ...init: InitArg<MaybeOptionalInit<paths["/terminal/{id}/event"], "post">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Update Terminal
 *
 * Update the details of a Terminal
 *
 * @param terminal_id The ID of the Terminal the event should be sent to.
 */
declare function terminal_update(client: PaystackClient, terminal_id: string, ...init: InitArg<MaybeOptionalInit<paths["/terminal/{terminal_id}"], "put">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Charge Authorization
 *
 * Charge all authorizations marked as reusable with this endpoint whenever you need to receive payments
 */
declare function transaction_chargeAuthorization(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/transaction/charge_authorization"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Check Authorization
 *
 * Check if an authorization code can be used for a charge.
 */
declare function transaction_checkAuthorization(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/transaction/check_authorization"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Get Transaction Event
 *
 * Fetch the event for a specific transaction.
 *
 * @param id The ID of the transaction
 */
declare function transaction_event(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/transaction/{id}/event"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Export Transactions
 *
 * Download transactions that occurred on your integration for a specific timeframe
 */
declare function transaction_export(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/transaction/export"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Transaction
 *
 * Fetch a transaction to get its details
 *
 * @param id The ID of the transaction to fetch
 */
declare function transaction_fetch(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/transaction/{id}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Initialize Transaction
 *
 * Create a new transaction
 */
declare function transaction_initialize(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/transaction/initialize"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * List Transactions
 *
 * List transactions carried out on your integration
 */
declare function transaction_list(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/transaction"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Partial Debit
 *
 * Retrieve part of a payment from a customer
 */
declare function transaction_partialDebit(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/transaction/partial_debit"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Get Transaction Session
 *
 * Fetch the session for a specific transaction.
 *
 * @param id The ID of the transaction
 */
declare function transaction_session(client: PaystackClient, id: number, ...init: InitArg<MaybeOptionalInit<paths["/transaction/{id}/session"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Transaction Timeline
 *
 * Fetch the steps taken from the initiation to the completion of a transaction
 *
 * @param id_or_reference The ID or the reference of the transaction
 */
declare function transaction_timeline(client: PaystackClient, id_or_reference: string, ...init: InitArg<MaybeOptionalInit<paths["/transaction/timeline/{id_or_reference}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Transaction Totals
 *
 * Get the total amount of all transactions
 */
declare function transaction_totals(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/transaction/totals"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Verify Transaction
 *
 * Verify a previously initiated transaction using it's reference
 *
 * @param reference The transaction reference to verify
 */
declare function transaction_verify(client: PaystackClient, reference: string, ...init: InitArg<MaybeOptionalInit<paths["/transaction/verify/{reference}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Initiate Bulk Transfer
 *
 * Batch multiple transfers in a single request.
 *
 * You need to disable the Transfers OTP requirement to use this endpoint.
 *
 */
declare function transfer_bulk(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/transfer/bulk"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Disable OTP for Transfers
 *
 * This is used in the event that you want to be able to complete transfers programmatically without use of OTPs.
 * No arguments required. You will get an OTP to complete the request.
 *
 */
declare function transfer_disableOtp(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/transfer/disable_otp"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Finalize Disabling OTP for Transfers
 *
 * Finalize the request to disable OTP on your transfers
 */
declare function transfer_disableOtpFinalize(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/transfer/disable_otp_finalize"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Enable OTP requirement for Transfers
 *
 * In the event that a customer wants to stop being able to complete transfers programmatically, this endpoint helps turn OTP requirement back on.
 * No arguments required.
 *
 */
declare function transfer_enableOtp(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/transfer/enable_otp"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Export Transfers
 *
 * Export a list of transfers carried out on your integration
 */
declare function transfer_exportTransfer(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/transfer/export"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Transfer
 *
 * Get details of a transfer on your integration
 *
 * @param id_or_code The transfer ID or code you want to fetch
 */
declare function transfer_fetch(client: PaystackClient, id_or_code: string, ...init: InitArg<MaybeOptionalInit<paths["/transfer/{id_or_code}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Finalize Transfer
 *
 * Finalize an initiated transfer
 */
declare function transfer_finalize(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/transfer/finalize_transfer"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Initiate Transfer
 *
 * Send money to your customers
 */
declare function transfer_initiate(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/transfer"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * List Transfers
 *
 * List the transfers made on your integration
 */
declare function transfer_list(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/transfer"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Resend OTP for Transfer
 *
 * Generates and send a new OTP to customer in the event they are having trouble receiving one.
 */
declare function transfer_resendOtp(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/transfer/resend_otp"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Verify Transfer
 *
 * Verify the status of a transfer on your integration
 *
 * @param reference Transfer reference
 */
declare function transfer_verify(client: PaystackClient, reference: string, ...init: InitArg<MaybeOptionalInit<paths["/transfer/verify/{reference}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Bulk Create Transfer Recipient
 *
 * Create multiple transfer recipients in batches. A duplicate account number will lead to the retrieval of the existing record.
 *
 */
declare function transferrecipient_bulk(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/transferrecipient/bulk"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Create Transfer Recipient
 *
 * Creates a new recipient. A duplicate account number will lead to the retrieval of the existing record.
 */
declare function transferrecipient_create(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/transferrecipient"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Delete Transfer Recipient
 *
 * Delete a transfer recipient (sets the transfer recipient to inactive)
 *
 * @param id_or_code An ID or code for the recipient whose details you want to receive.
 */
declare function transferrecipient_delete(client: PaystackClient, id_or_code: string, ...init: InitArg<MaybeOptionalInit<paths["/transferrecipient/{id_or_code}"], "delete">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Transfer recipient
 *
 * Fetch the details of a transfer recipient
 *
 * @param id_or_code An ID or code for the recipient whose details you want to receive.
 */
declare function transferrecipient_fetch(client: PaystackClient, id_or_code: string, ...init: InitArg<MaybeOptionalInit<paths["/transferrecipient/{id_or_code}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * List Transfer Recipients
 *
 * List transfer recipients available on your integration
 */
declare function transferrecipient_list(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/transferrecipient"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Update Transfer Recipient
 *
 * Update the details of a transfer recipient
 *
 * @param id_or_code An ID or code for the recipient whose details you want to receive.
 */
declare function transferrecipient_update(client: PaystackClient, id_or_code: string, ...init: InitArg<MaybeOptionalInit<paths["/transferrecipient/{id_or_code}"], "put">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Add Split Code to Virtual Terminal
 *
 * Add Split Code to Virtual Terminal
 *
 * @param code Code of the Virtual Terminal
 */
declare function virtualTerminal_addSplitCode(client: PaystackClient, code: string, ...init: InitArg<MaybeOptionalInit<paths["/virtual_terminal/{code}/split_code"], "put">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Create Virtual Terminal
 *
 * Create a Virtual Terminal on your integration
 */
declare function virtualTerminal_create(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/virtual_terminal"], "post">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Deactivate Virtual Terminal
 *
 * Deactivate a Virtual Terminal on your integration
 *
 * @param code Code of the Virtual Terminal
 */
declare function virtualTerminal_deactivate(client: PaystackClient, code: string, ...init: InitArg<MaybeOptionalInit<paths["/virtual_terminal/{code}/deactivate"], "put">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Remove Split Code from Virtual Terminal
 *
 * Remove Split Code from Virtual Terminal
 *
 * @param code Code of the Virtual Terminal
 */
declare function virtualTerminal_deleteSplitCode(client: PaystackClient, code: string, ...init: InitArg<MaybeOptionalInit<paths["/virtual_terminal/{code}/split_code"], "delete">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Assign Destination to Virtual Terminal
 *
 * Add a destination (WhatsApp number) to a Virtual Terminal on your integration
 *
 * @param code Code of the Virtual Terminal
 */
declare function virtualTerminal_destinationAssign(client: PaystackClient, code: string, ...init: InitArg<MaybeOptionalInit<paths["/virtual_terminal/{code}/destination/assign"], "post">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Unassign Destination from Virtual Terminal
 *
 * Unassign a destination (WhatsApp Number) from a Virtual Terminal on your integration
 *
 * @param code Code of the Virtual Terminal
 */
declare function virtualTerminal_destinationUnassign(client: PaystackClient, code: string, ...init: InitArg<MaybeOptionalInit<paths["/virtual_terminal/{code}/destination/unassign"], "post">, true>): Promise<PaystackResponse<unknown>>;
/**
 * Fetch Virtual Terminal
 *
 * Fetch a Virtual Terminal on your integration
 *
 * @param code Code of the Virtual Terminal
 */
declare function virtualTerminal_fetch(client: PaystackClient, code: string, ...init: InitArg<MaybeOptionalInit<paths["/virtual_terminal/{code}"], "get">, true>): Promise<PaystackResponse<unknown>>;
/**
 * List Virtual Terminals
 *
 * List Virtual Terminals on your integration
 */
declare function virtualTerminal_list(client: PaystackClient, ...init: InitArg<MaybeOptionalInit<paths["/virtual_terminal"], "get">, false>): Promise<PaystackResponse<unknown>>;
/**
 * Update Virtual Terminal
 *
 * Update a Virtual Terminal on your integration
 *
 * @param code Code of the Virtual Terminal
 */
declare function virtualTerminal_update(client: PaystackClient, code: string, ...init: InitArg<MaybeOptionalInit<paths["/virtual_terminal/{code}"], "put">, true>): Promise<PaystackResponse<unknown>>;
declare function bindOperations(client: PaystackClient): {
  readonly applePay: {
    /**
    * List Domains
    *
    * Lists all registered domains on your integration. Returns an empty array if no domains have been added.
     */
    readonly listDomain: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          use_cursor?: boolean;
          next?: string;
          previous?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["ApplePayDomainsSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Register Domain
    *
    * Register a top-level domain or subdomain for your Apple Pay integration.
    > This endpoint can only be called with one domain or subdomain at a time.
     */
    readonly registerDomain: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ApplePayParam"];
          "application/x-www-form-urlencoded": components["schemas"]["ApplePayParam"];
        };
      };
      responses: {
        200: components["responses"]["ApplePayOkResponse"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Unregister Domain
    *
    * Unregister a top-level domain or subdomain previously used for your Apple
    Pay integration.
     */
    readonly unregisterDomain: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ApplePayParam"];
          "application/x-www-form-urlencoded": components["schemas"]["ApplePayParam"];
        };
      };
      responses: {
        200: components["responses"]["Ok"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly balance: {
    /**
    * Fetch Balance
    *
    * Fetch the available balance on your integration
     */
    readonly fetch: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["BalanceCheckResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Balance Ledger
    *
    * Fetch all pay-ins and pay-outs that occured on your integration
     */
    readonly ledger: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          perPage?: number;
          page?: number;
          from?: string;
          to?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["BalanceFetchLedgerResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly bank: {
    /**
    * List Banks
    *
    * Get a list of all supported banks and their properties
     */
    readonly list: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          country?: "ghana" | "kenya" | "nigeria" | "south africa";
          currency?: "GHS" | "KES" | "NGN" | "ZAR";
          use_cursor?: boolean;
          perPage?: number;
          page?: number;
          next?: string;
          previous?: string;
          pay_with_bank_transfer?: boolean;
          pay_with_bank?: boolean;
          enabled_for_verification?: boolean;
          gateway?: "emandate" | "digitalbankmandate";
          type?: "ghipss" | "mobile_money" | "nuban" | "kepss" | "basa";
          include_nip_sort_code?: boolean;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["MiscellaneousListBanksSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Resolve Account Number
    *
    * Resolve an account number to confirm the name associated with it
     */
    readonly resolveAccountNumber: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          account_number?: string;
          bank_code?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["VerificationResolveAccountNumberSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Validate Bank Account
    *
    * Confirm the authenticity of a customer's account number before sending money
     */
    readonly validateAccountNumber: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["BankValidateRequest"];
          "application/x-www-form-urlencoded": components["schemas"]["BankValidateRequest"];
        };
      };
      responses: {
        200: components["responses"]["VerificationValidateAccountSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly bulkCharge: {
    /**
    * List Charges in a Batch
    *
    * This endpoint retrieves the charges associated with a specified batch code
     */
    readonly charges: (id_or_code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          perPage?: number;
          page?: number;
          status?: "pending" | "success" | "failed";
          from?: string;
          to?: string;
        };
        header?: never;
        path: {
          id_or_code: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["BulkChargeFetchBulkBatchChargesResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Bulk Charge Batch
    *
    * This endpoint retrieves a specific batch code. It also returns useful information on its progress by
    way of the `total_charges` and `pending_charges` attributes.
     */
    readonly fetch: (id_or_code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id_or_code: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["BulkChargeFetchResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Initiate Bulk Charge
    *
    * Charge multiple customers in batches
     */
    readonly initiate: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["BulkChargeInitiate"][];
          "application/x-www-form-urlencoded": components["schemas"]["BulkChargeInitiate"][];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["BulkChargeInitiateResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Bulk Charge Batches
    *
    * List all bulk charge batches.
     */
    readonly list: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          perPage?: number;
          page?: number;
          from?: string;
          to?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["BulkChargeListResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Pause Bulk Charge Batch
    *
    * Pause the processing of a charge batch
     */
    readonly pause: (code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          code: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["BulkChargePauseResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Resume Bulk Charge Batch
    *
    * Resume the processing of a previously paused charge batch
     */
    readonly resume: (code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          code: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["BulkChargeResumeResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly capitecPay: {
    /**
    * Requery Transaction
    *
    * Check the status of a charge made with Capitec Pay. This endpoint should be used from your frontend application as it requires the use of your public key for request authorization.
     */
    readonly requery: (ref: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          ref: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["CapitecPayRequeryResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly charge: {
    /**
    * Check pending charge
    *
    * When you get `pending` as a charge status or if there was an exception when calling any of the `/charge` endpoints, wait 10 seconds or more, then make a check to see if its status has changed. Don't call too early as you may get a lot more pending than you should.
     */
    readonly check: (reference: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          reference: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["ChargeCheckPendingResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Create Charge
    *
    * Initiate a payment by integrating the payment channel of your choice.
     */
    readonly create: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ChargeCreate"] & {
            bank?: components["schemas"]["Bank"];
          } & {
            mobile_money?: components["schemas"]["MobileMoney"];
          } & {
            ussd?: components["schemas"]["USSD"];
          } & {
            eft?: components["schemas"]["EFT"];
          };
          "application/x-www-form-urlencoded": components["schemas"]["ChargeCreate"] & {
            bank?: components["schemas"]["Bank"];
          } & {
            mobile_money?: components["schemas"]["MobileMoney"];
          } & {
            ussd?: components["schemas"]["USSD"];
          } & {
            eft?: components["schemas"]["EFT"];
          };
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["ChargeCreateResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Submit Address
    *
    * Send the details of the customer's address for address verification
     */
    readonly submitAddress: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ChargeSubmitAddress"];
          "application/x-www-form-urlencoded": components["schemas"]["ChargeSubmitAddress"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["ChargeCheckPendingResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Submit Birthday
    *
    * Submit the customer's birthday when requested
     */
    readonly submitBirthday: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ChargeSubmitBirthday"];
          "application/x-www-form-urlencoded": components["schemas"]["ChargeSubmitBirthday"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["ChargeSubmitBirthdayResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Submit OTP
    *
    * Submit OTP to complete a charge
     */
    readonly submitOtp: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ChargeSubmitOTP"];
          "application/x-www-form-urlencoded": components["schemas"]["ChargeSubmitOTP"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["ChargeSubmitOtpResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Submit Phone
    *
    * Submit phone number when requested
     */
    readonly submitPhone: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ChargeSubmitPhone"];
          "application/x-www-form-urlencoded": components["schemas"]["ChargeSubmitPhone"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["ChargeSubmitPhoneResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Submit PIN
    *
    * Submit PIN to continue a charge
     */
    readonly submitPin: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ChargeSubmitPin"];
          "application/x-www-form-urlencoded": components["schemas"]["ChargeSubmitPin"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["ChargeSubmitPinResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly customer: {
    /**
    * Create Customer
    *
    * Create a customer on your integration
     */
    readonly create: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["CustomerCreate"];
          "application/x-www-form-urlencoded": components["schemas"]["CustomerCreate"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["CustomerCreateResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Deactivate Authorization
    *
    * Deactivate an authorization for any payment channel.
     */
    readonly deactivateAuthorization: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["CustomerDeactivateAuthorization"];
          "application/x-www-form-urlencoded": components["schemas"]["CustomerDeactivateAuthorization"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["CustomerDeactivateAuthorizationResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Direct Debit Activation Charge
    *
    * Trigger an activation charge on an inactive mandate on behalf of your customer
     */
    readonly directDebitActivationCharge: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["CustomerDirectDebitActivationChargeRequest"];
          "application/x-www-form-urlencoded": components["schemas"]["CustomerDirectDebitActivationChargeRequest"];
        };
      };
      responses: {
        200: components["responses"]["CustomerDirectDebitActivationChargeSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Customer
    *
    * Get details of a customer on your integration.
     */
    readonly fetch: (email_or_code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          email_or_code: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["CustomerFetchResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Mandate Authorizations
    *
    * Get the list of direct debit mandates associated with a customer
     */
    readonly fetchMandateAuthorizations: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["CustomerFetchMandateAuthorizationsSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Initialize Authorization
    *
    * Initiate a request to create a reusable authorization code for recurring transactions
     */
    readonly initializeAuthorization: (init: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody: {
        content: {
          "application/json": components["schemas"]["CustomerAuthorizationInitializeRequest"];
          "application/x-www-form-urlencoded": components["schemas"]["CustomerAuthorizationInitializeRequest"];
        };
      };
      responses: {
        200: components["responses"]["CustomerAuthorizationInitializeSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>) => Promise<PaystackResponse<unknown>>;
    /**
    * Initialize Direct Debit
    *
    * Initialize the process of linking an account to a customer for Direct Debit transactions
     */
    readonly initializeDirectDebit: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["CustomerInitializeDirectDebitRequest"];
          "application/x-www-form-urlencoded": components["schemas"]["CustomerInitializeDirectDebitRequest"];
        };
      };
      responses: {
        200: components["responses"]["CustomerInitializeDirectDebitSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Customers
    *
    * List customers available on your integration
     */
    readonly list: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          use_cursor?: boolean;
          next?: string;
          previous?: string;
          from?: string;
          to?: string;
          perPage?: number;
          page?: number;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["CustomerListResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Set Risk Action
    *
    * Set customer's risk action by whitelisting or blacklisting the customer
     */
    readonly riskAction: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["CustomerRiskAction"];
          "application/x-www-form-urlencoded": components["schemas"]["CustomerRiskAction"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["CustomerWhitelistBlacklistResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Update Customer
    *
    * Update a customer's details on your integration
     */
    readonly update: (email_or_code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          email_or_code: string;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["CustomerUpdate"];
          "application/x-www-form-urlencoded": components["schemas"]["CustomerUpdate"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["CustomerUpdateResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Validate Customer
    *
    * Validate a customer's identity
     */
    readonly validate: (customer_code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          customer_code: string;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["CustomerValidate"];
          "application/x-www-form-urlencoded": components["schemas"]["CustomerValidate"];
        };
      };
      responses: {
        202: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["CustomerValidateResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Verify Authorization
    *
    * Check the status of an authorization request
     */
    readonly verifyAuthorization: (reference: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          reference: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["CustomerAuthorizationVerifySuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly dedicatedAccount: {
    /**
    * Split Dedicated Account Transaction
    *
    * Split a dedicated virtual account transaction with one or more accounts
     */
    readonly addSplit: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["DedicatedVirtualAccountSplit"];
          "application/x-www-form-urlencoded": components["schemas"]["DedicatedVirtualAccountSplit"];
        };
      };
      responses: {
        200: components["responses"]["Ok"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Assign Dedicated Account
    *
    * With this endpoint, you can create a customer, validate the customer, and assign a DVA to the customer.
     */
    readonly assign: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["DedicatedVirtualAccountAssign"];
          "application/x-www-form-urlencoded": components["schemas"]["DedicatedVirtualAccountAssign"];
        };
      };
      responses: {
        200: components["responses"]["Ok"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Bank Providers
    *
    * Get available bank providers for a dedicated virtual account
     */
    readonly availableProviders: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["Ok"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Create Dedicated Account
    *
    * Create a dedicated virtual account for an existing customer
     */
    readonly create: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["DedicatedVirtualAccountCreate"];
          "application/x-www-form-urlencoded": components["schemas"]["DedicatedVirtualAccountCreate"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["DedicatedNubanCreateResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Deactivate Dedicated Account
    *
    * Deactivate a dedicated virtual account on your integration.
     */
    readonly deactivate: (id: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["DedicatedNubanDeactivateResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Dedicated Account
    *
    * Get details of a dedicated virtual account on your integration.
     */
    readonly fetch: (id: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["DedicatedNubanFetchResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Dedicated Accounts
    *
    * List dedicated virtual accounts available on your integration.
     */
    readonly list: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          active?: boolean;
          customer?: number;
          currency?: "NGN" | "GHS";
          provider_slug?: string;
          bank_id?: string;
          perPage?: number;
          page?: number;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["DedicatedNubanListResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Remove Split from Dedicated Account
    *
    * If you've previously set up split payment for transactions on a dedicated virtual account, you can remove it with this endpoint
     */
    readonly removeSplit: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["DedicatedVirtualAccountRemoveSplit"];
          "application/x-www-form-urlencoded": components["schemas"]["DedicatedVirtualAccountRemoveSplit"];
        };
      };
      responses: {
        200: components["responses"]["Ok"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Requery Dedicated Account
    *
    * Requery Dedicated Virtual Account for new transactions
     */
    readonly requery: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          account_number?: string;
          provider_slug?: string;
          date?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["Ok"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly directdebit: {
    /**
    * List Mandate Authorizations
    *
    * Get a list of all the direct debit mandates on your integration
     */
    readonly listMandateAuthorizations: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          cursor?: string;
          status?: "pending" | "active" | "revoked";
          per_page?: number;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["CustomerFetchMandateAuthorizationsSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Trigger Activation Charge
    *
    * Trigger activation charge for specified customers
     */
    readonly triggerActivationCharge: (init: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody: {
        content: {
          "application/json": components["schemas"]["DirectDebitActivationChargeRequest"];
        };
      };
      responses: {
        200: components["responses"]["DirectDebitActivationChargeSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>) => Promise<PaystackResponse<unknown>>;
  };
  readonly dispute: {
    /**
    * Export Disputes
    *
    * Export the disputes available on your integration
     */
    readonly download: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          perPage?: number;
          page?: number;
          status?: "awaiting-merchant-feedback" | "awaiting-bank-feedback" | "pending" | "resolved";
          from?: string;
          to?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["DisputeExportSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Add Evidence
    *
    * Provide evidence for a dispute
     */
    readonly evidence: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["DisputeEvidence"];
          "application/x-www-form-urlencoded": components["schemas"]["DisputeEvidence"];
        };
      };
      responses: {
        200: components["responses"]["DisputeAddEvidenceSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Dispute
    *
    * Fetch a transaction dispute
     */
    readonly fetch: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["DisputeFetchSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Disputes
    *
    * List transaction disputes filed by customers
     */
    readonly list: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          perPage?: number;
          page?: number;
          status?: "awaiting-merchant-feedback" | "awaiting-bank-feedback" | "pending" | "resolved";
          transaction?: string;
          from?: string;
          to?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["DisputeListSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Resolve Dispute
    *
    * Resolve a transaction dispute
     */
    readonly resolve: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["DisputeResolve"];
          "application/x-www-form-urlencoded": components["schemas"]["DisputeResolve"];
        };
      };
      responses: {
        200: components["responses"]["DisputeResolveSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Transaction Disputes
    *
    * List all disputes filed for a transaction
     */
    readonly transaction: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["DisputeListTransactionSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Update Dispute
    *
    * Update a transaction dispute
     */
    readonly update: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["DisputeUpdate"];
          "application/x-www-form-urlencoded": components["schemas"]["DisputeUpdate"];
        };
      };
      responses: {
        200: components["responses"]["DisputeUpdateSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Upload URL
    *
    * Get the URL to upload a dispute evidence
     */
    readonly uploadUrl: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["DisputeUploadURLSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly integration: {
    /**
    * Fetch Payment Session Timeout
    *
    * Fetch the session timeout of a transaction
     */
    readonly fetchPaymentSessionTimeout: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["ControlPanelFetchPaymentSessionTimeoutResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Update Payment Session Timeout
    *
    * Update the session timeout of a transaction
     */
    readonly updatePaymentSessionTimeout: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["PaymentSession"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["ControlPanelUpdatePaymentSessionTimeoutResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly misc: {
    /**
    * Internal path for schema generation
    *
    * This path is internal and used to ensure that schemas like WebhookEvent are considered 'used' for SDK generation and linting.
     */
    readonly generateWebhookEventTypes: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["WebhookEvent"];
          };
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly miscellaneous: {
    /**
    * List States (AVS)
    *
    * Get a list of states for a country for address verification
     */
    readonly avs: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          country?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["MiscellaneousListStatesSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Countries
    *
    * List all supported countries on Paystack
     */
    readonly listCountries: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["MiscellaneousListCountriesSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Resolve Card BIN
    *
    * Get the details of a card BIN
     */
    readonly resolveCardBin: (bin: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          bin: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["VerificationResolveCardBINSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly order: {
    /**
    * Create Order
    *
    * Create an order for selected items
     */
    readonly create: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["OrderCreate"];
          "application/x-www-form-urlencoded": components["schemas"]["OrderCreate"];
        };
      };
      responses: {
        200: components["responses"]["OrderCreateSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Order
    *
    * Fetch the details of a previously created order
     */
    readonly fetch: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["OrderFetchSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Orders
    *
    * List the previously created orders
     */
    readonly list: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          perPage?: number;
          page?: number;
          from?: string;
          to?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["OrderListSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Product Orders
    *
    * Fetch all orders for a particular product
     */
    readonly product: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["OrderFetchProductSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Validate Order
    *
    * Validate a pay for me order
     */
    readonly validate: (code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          code: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["OrderValidateSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly page: {
    /**
    * Add Products
    *
    * Add products to a previously created payment page. You can only add products to pages
    that was created with a `product` type.
     */
    readonly addProducts: (id: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: string;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["PageProduct"];
          "application/x-www-form-urlencoded": components["schemas"]["PageProduct"];
        };
      };
      responses: {
        200: components["responses"]["PageAddProductsSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Check Slug Availability
    *
    * Check if a custom slug is available for use when creating a payment page
     */
    readonly checkSlugAvailability: (slug: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          slug: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["PageCheckSlugAvailabilitySuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Create Page
    *
    * Create a webpage to receive payments
     */
    readonly create: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["PageCreate"];
          "application/x-www-form-urlencoded": components["schemas"]["PageCreate"];
        };
      };
      responses: {
        200: components["responses"]["PageCreateSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Page
    *
    * Get a previously created payment page
     */
    readonly fetch: (id_or_slug: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id_or_slug: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["PageFetchSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Pages
    *
    * List all previously created payment pages
     */
    readonly list: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          perPage?: number;
          page?: number;
          from?: string;
          to?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["PageListSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Update Page
    *
    * Update a previously created payment page
     */
    readonly update: (id_or_slug: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id_or_slug: string;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["PageUpdate"];
          "application/x-www-form-urlencoded": components["schemas"]["PageUpdate"];
        };
      };
      responses: {
        200: components["responses"]["PageUpdateSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly paymentRequest: {
    /**
    * Archive Payment Request
    *
    * Archive a payment request to clean up your records. An archived payment request cannot be verified and will not
    be returned when listing all previously created payment requests.
     */
    readonly archive: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["PaymentRequestArchiveSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Create Payment Request
    *
    * Create a new payment request by issuing an invoice to a customer
     */
    readonly create: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["PaymentRequestCreate"];
          "application/x-www-form-urlencoded": components["schemas"]["PaymentRequestCreate"];
        };
      };
      responses: {
        200: components["responses"]["PaymentRequestCreateSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Payment Request
    *
    * Fetch a previously created payment request
     */
    readonly fetch: (id_or_code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id_or_code: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["PaymentRequestViewSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Finalize Payment Request
    *
    * Finalise the creation of a draft payment request for a customer
     */
    readonly finalize: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["PaymentRequestFinalizeSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Payment Request
    *
    * List all previously created payment requests to your customers
     */
    readonly list: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          perPage?: number;
          page?: number;
          customer?: string;
          status?: "draft" | "pending" | "success" | "failed";
          currency?: string;
          from?: string;
          to?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["PaymentRequestListSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Send Notification
    *
    * Trigger an email reminder to a customer for a previously created payment request
     */
    readonly notify: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["PaymentRequestSendNotificationSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Payment Request Total
    *
    * Get the metric of all pending and successful payment requests
     */
    readonly totals: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["PaymentRequestTotalSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Update Payment Request
    *
    * Update a previously created payment request
     */
    readonly update: (id_or_code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id_or_code: string;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["PaymentRequestUpdate"];
          "application/x-www-form-urlencoded": components["schemas"]["PaymentRequestUpdate"];
        };
      };
      responses: {
        200: components["responses"]["PaymentRequestUpdateSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Verify Payment Request
    *
    * Verify the status of a previously created payment request
     */
    readonly verify: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["PaymentRequestVerifySuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly plan: {
    /**
    * Create Plan
    *
    * Create a plan for recurring payments
     */
    readonly create: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["PlanCreate"];
          "application/x-www-form-urlencoded": components["schemas"]["PlanCreate"];
        };
      };
      responses: {
        200: components["responses"]["PlanCreateSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Plan
    *
    * Get the details of a payment plan
     */
    readonly fetch: (id_or_code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id_or_code: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["PlanFetchSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Plans
    *
    * List all recurring payment plans
     */
    readonly list: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          perPage?: number;
          page?: number;
          status?: string;
          interval?: "daily" | "weekly" | "monthly" | "quarterly" | "biannually" | "annually";
          amount?: number;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["PlanListSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Update Plan
    *
    * Update a plan details on your integration
     */
    readonly update: (id_or_code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id_or_code: string;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["PlanUpdate"];
          "application/x-www-form-urlencoded": components["schemas"]["PlanUpdate"];
        };
      };
      responses: {
        200: components["responses"]["PlanUpdateSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly preauthorization: {
    /**
    * Capture Preauthorization
    *
    * Charge a preauthorized transaction upon service delivery
     */
    readonly capture: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["PreAuthorizationCapture"];
          "application/x-www-form-urlencoded": components["schemas"]["PreAuthorizationCapture"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["PreAuthorizationCaptureResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Initialize Preauthorization
    *
    * Initialize a preauthorization transaction for a new customer
     */
    readonly initialize: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["PreAuthorizationInitialize"];
          "application/x-www-form-urlencoded": components["schemas"]["PreAuthorizationInitialize"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["PreAuthorizationInitializeResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Preauthorizations
    *
    * List preauthorizations carried out on your integration
     */
    readonly list: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          perPage?: number;
          page?: number;
          from?: string;
          to?: string;
          status?: "authorized" | "captured" | "released" | "ongoing" | "failed" | "abandoned";
          amount?: number;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["PreAuthorizationListResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Release Preauthorization
    *
    * For when a customer cancels an order or you want to release the hold from their card.
     */
    readonly release: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["PreAuthorizationRelease"];
          "application/x-www-form-urlencoded": components["schemas"]["PreAuthorizationRelease"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["PreAuthorizationReleaseResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Reserve Preauthorization
    *
    * Hold an amount using an existing customer's authorization that's marked reusable.
     */
    readonly reserve_authorization: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["PreAuthorizationReserve"];
          "application/x-www-form-urlencoded": components["schemas"]["PreAuthorizationReserve"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["PreAuthorizationReserveWithAuthCodeResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Verify Preauthorization
    *
    * Fetch and confirm the status of a preauthorized transaction.
     */
    readonly verify: (reference: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          reference: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["PreAuthorizationVerifyResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly product: {
    /**
    * Create Product
    *
    * Create a new product on your integration
     */
    readonly create: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ProductCreate"];
          "application/x-www-form-urlencoded": components["schemas"]["ProductCreate"];
        };
      };
      responses: {
        201: components["responses"]["ProductCreateSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Delete Product
    *
    * Delete a previously created product
     */
    readonly delete: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["ProductDeleteSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Product
    *
    * Fetch a previously created product
     */
    readonly fetch: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["ProductFetchSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Products
    *
    * List all previously created products
     */
    readonly list: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          perPage?: number;
          page?: number;
          active?: boolean;
          from?: string;
          to?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["ProductListsSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Update product
    *
    * Update a previously created product
     */
    readonly update: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ProductUpdate"];
          "application/x-www-form-urlencoded": components["schemas"]["ProductUpdate"];
        };
      };
      responses: {
        200: components["responses"]["ProductUpdateSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly refund: {
    /**
    * Create Refund
    *
    * Initiate a refund for a previously completed transaction
     */
    readonly create: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["RefundCreate"];
          "application/x-www-form-urlencoded": components["schemas"]["RefundCreate"];
        };
      };
      responses: {
        200: components["responses"]["RefundCreateSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Refund
    *
    * Get a previously created refund
     */
    readonly fetch: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["RefundFetchSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Refunds
    *
    * List previously created refunds
     */
    readonly list: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          transaction?: string;
          currency?: string;
          perPage?: number;
          page?: number;
          from?: string;
          to?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["RefundListSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Retry Refund
    *
    * Retry a refund with a `needs-attention` status by providing the bank account details of a customer.
     */
    readonly retry: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["RefundRetry"];
          "application/x-www-form-urlencoded": components["schemas"]["RefundRetry"];
        };
      };
      responses: {
        200: components["responses"]["RefundRetrySuccess"];
        422: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly settlements: {
    /**
    * List Settlements
    *
    * List settlements made to your settlement accounts
     */
    readonly fetch: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          perPage?: number;
          page?: number;
          from?: string;
          to?: string;
          status?: "success" | "failed" | "processing" | "pending";
          subaccount?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SettlementListResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Settlement Transactions
    *
    * Get the transactions that make up a particular settlement
     */
    readonly transaction: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          perPage?: number;
          page?: number;
          from?: string;
          to?: string;
        };
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SettlementTransactionsResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly split: {
    /**
    * Add Subaccount to Split
    *
    * Add a subaccount to a split configuration, or update the share of an existing subaccount
     */
    readonly addSubaccount: (id: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: string;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["SplitSubaccounts"];
          "application/x-www-form-urlencoded": components["schemas"]["SplitSubaccounts"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SplitAddUpdateSubaccountResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Create Split
    *
    * Create a split configuration for transactions
     */
    readonly create: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["SplitCreate"];
          "application/x-www-form-urlencoded": components["schemas"]["SplitCreate"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SplitCreateResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Split
    *
    * Get details of a split configuration for a transaction
     */
    readonly fetch: (id: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SplitFetchResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Splits
    *
    * List the transaction splits available on your integration
     */
    readonly list: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          subaccount_code?: string;
          name?: string;
          active?: boolean;
          sort_by?: string;
          perPage?: number;
          page?: number;
          from?: string;
          to?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SplitListResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Remove Subaccount from split
    *
    * Remove a subaccount from a split configuration
     */
    readonly removeSubaccount: (id: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: string;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["SplitSubaccountRemove"];
          "application/x-www-form-urlencoded": components["schemas"]["SplitSubaccountRemove"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SplitRemoveSubaccountResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Update Split
    *
    * Update a split configuration for transactions
     */
    readonly update: (id: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: string;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["SplitUpdate"];
          "application/x-www-form-urlencoded": components["schemas"]["SplitUpdate"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SplitUpdateResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly storefront: {
    /**
    * Add Products to Storefront
    *
    * Add previously created products to a Storefront
     */
    readonly addProducts: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["StorefrontAddProducts"];
          "application/x-www-form-urlencoded": components["schemas"]["StorefrontAddProducts"];
        };
      };
      responses: {
        200: components["responses"]["Ok"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Create Storefront
    *
    * Create a digital shop to manage and display your products
     */
    readonly create: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["StorefrontCreate"];
          "application/x-www-form-urlencoded": components["schemas"]["StorefrontCreate"];
        };
      };
      responses: {
        200: components["responses"]["StorefrontCreateSuccess"];
        400: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Delete Storefront
    *
    * Delete a previously created Storefront
     */
    readonly delete: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["StorefrontDeleteSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Duplicate Storefront
    *
    * Duplicate a previously created Storefront
     */
    readonly duplicate: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["Ok"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Storefront
    *
    * Get the details of a previously created Storefront
     */
    readonly fetch: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["StorefrontFetchSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Storefront Orders
    *
    * Fetch all orders in your Storefront
     */
    readonly fetchOrders: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["Ok"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Storefronts
    *
    * List the storefronts you previously created
     */
    readonly list: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          perPage?: number;
          page?: number;
          status?: "active" | "inactive";
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["StorefrontListSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Storefront Products
    *
    * List the products in a Storefront
     */
    readonly listProducts: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["Ok"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Publish Storefront
    *
    * Make your Storefront publicly available
     */
    readonly publish: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["Ok"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Update Storefront
    *
    * Update the details of a previously created Storefront
     */
    readonly update: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["StorefrontUpdate"];
          "application/x-www-form-urlencoded": components["schemas"]["StorefrontUpdate"];
        };
      };
      responses: {
        200: components["responses"]["StorefrontUpdateSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Verify Storefront Slug
    *
    * Verify the availability of a slug before using it for your Storefront
     */
    readonly verifySlug: (slug: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          slug: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["Ok"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly subaccount: {
    /**
    * Create Subaccount
    *
    * Create a subacount for a partner
     */
    readonly create: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["SubaccountCreate"];
          "application/x-www-form-urlencoded": components["schemas"]["SubaccountCreate"];
        };
      };
      responses: {
        201: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SubaccountCreateResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Subaccount
    *
    * Get details of a subaccount on your integration
     */
    readonly fetch: (id_or_code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id_or_code: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SubaccountFetchResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Subaccounts
    *
    * List subaccounts available on your integration
     */
    readonly list: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          perPage?: number;
          page?: number;
          from?: string;
          to?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SubaccountListResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Update Subaccount
    *
    * Update a subaccount details on your integration
     */
    readonly update: (id_or_code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id_or_code: string;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["SubaccountUpdate"];
          "application/x-www-form-urlencoded": components["schemas"]["SubaccountUpdate"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SubaccountUpdateResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly subscription: {
    /**
    * Create Subscription
    *
    * Create a subscription a customer
     */
    readonly create: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["SubscriptionCreate"];
          "application/x-www-form-urlencoded": components["schemas"]["SubscriptionCreate"];
        };
      };
      responses: {
        200: components["responses"]["SubscriptionCreateSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Disable Subscription
    *
    * Disable a subscription on your integration
     */
    readonly disable: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["SubscriptionToggle"];
          "application/x-www-form-urlencoded": components["schemas"]["SubscriptionToggle"];
        };
      };
      responses: {
        200: components["responses"]["SubscriptionDisableSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Enable Subscription
    *
    * Enable a subscription on your integration
     */
    readonly enable: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["SubscriptionToggle"];
          "application/x-www-form-urlencoded": components["schemas"]["SubscriptionToggle"];
        };
      };
      responses: {
        200: components["responses"]["Ok"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Subscription
    *
    * Get details of a customer's subscription
     */
    readonly fetch: (id_or_code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id_or_code: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["SubscriptionFetchSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Subscriptions
    *
    * List all subscriptions available on your integration
     */
    readonly list: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          perPage?: number;
          page?: number;
          plan?: number;
          customer?: number;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["SubscriptionListSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Send Update Subscription Link
    *
    * Email a customer a link for updating the card on their subscription
     */
    readonly manageEmail: (code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          code: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["Ok"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Generate Update Subscription Link
    *
    * Generate a link for updating the card on a subscription
     */
    readonly manageLink: (code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          code: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["Ok"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly terminal: {
    /**
    * Commission Terminal
    *
    * Activate your debug device by linking it to your integration
     */
    readonly commission: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["TerminalActivationToggle"];
          "application/x-www-form-urlencoded": components["schemas"]["TerminalActivationToggle"];
        };
      };
      responses: {
        200: components["responses"]["TerminalCommissionDeviceSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Decommission Terminal
    *
    * Unlink your debug device from your integration
     */
    readonly decommission: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["TerminalActivationToggle"];
          "application/x-www-form-urlencoded": components["schemas"]["TerminalActivationToggle"];
        };
      };
      responses: {
        200: components["responses"]["TerminalDecommissionDeviceSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Terminal
    *
    * Get the details of a Terminal
     */
    readonly fetch: (terminal_id: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          terminal_id: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["TerminalGetSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Event Status
    *
    * Check the status of an event sent to the Terminal
     */
    readonly fetchEventStatus: (terminal_id: string, event_id: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          terminal_id: string;
          event_id: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["Ok"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Terminal Status
    *
    * Check the availiability of a Terminal before sending an event to it
     */
    readonly fetchTerminalStatus: (terminal_id: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          terminal_id: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["TerminalGetStatusSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Terminals
    *
    * List the Terminals available on your integration
     */
    readonly list: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          next?: string;
          previous?: string;
          perPage?: number;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["TerminalListsSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Send Event
    *
    * Send an event from your application to the Paystack Terminal
     */
    readonly sendEvent: (id: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: string;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["TerminalSendEvent"];
          "application/x-www-form-urlencoded": components["schemas"]["TerminalSendEvent"];
        };
      };
      responses: {
        200: components["responses"]["Ok"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Update Terminal
    *
    * Update the details of a Terminal
     */
    readonly update: (terminal_id: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          terminal_id: string;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["TerminalUpate"];
          "application/x-www-form-urlencoded": components["schemas"]["TerminalUpate"];
        };
      };
      responses: {
        200: components["responses"]["TerminalUpdateSuccess"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly transaction: {
    /**
    * Charge Authorization
    *
    * Charge all authorizations marked as reusable with this endpoint whenever you need to receive payments
     */
    readonly chargeAuthorization: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["TransactionChargeAuthorization"];
          "application/x-www-form-urlencoded": components["schemas"]["TransactionChargeAuthorization"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["ChargeAuthorizationResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Check Authorization
    *
    * Check if an authorization code can be used for a charge.
     */
    readonly checkAuthorization: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/x-www-form-urlencoded": components["schemas"]["TransactionCheckAuthorization"];
          "application/json": components["schemas"]["TransactionCheckAuthorization"];
        };
      };
      responses: {
        200: components["responses"]["Ok"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Get Transaction Event
    *
    * Fetch the event for a specific transaction.
     */
    readonly event: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["Ok"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Export Transactions
    *
    * Download transactions that occurred on your integration for a specific timeframe
     */
    readonly export: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          perPage?: number;
          page?: number;
          from?: string;
          to?: string;
          status?: "success" | "failed" | "abandoned" | "reversed" | "all";
          customer?: number;
          currency?: string;
          amount?: number;
          settled?: boolean;
          settlement?: number;
          payment_page?: number;
          subaccount_code?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["TransactionExportResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Transaction
    *
    * Fetch a transaction to get its details
     */
    readonly fetch: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["TransactionFetchResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Initialize Transaction
    *
    * Create a new transaction
     */
    readonly initialize: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["TransactionInitialize"];
          "application/x-www-form-urlencoded": components["schemas"]["TransactionInitialize"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["TransactionInitializeResponse"];
          };
        };
        400: components["responses"]["TransactionInitializeBadRequestResponse"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Transactions
    *
    * List transactions carried out on your integration
     */
    readonly list: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          use_cursor?: boolean;
          next?: string;
          previous?: string;
          perPage?: number;
          page?: number;
          from?: string;
          to?: string;
          status?: "success" | "failed" | "abandoned" | "reversed";
          source?: "merchantApi" | "checkout" | "pos" | "virtualTerminal";
          terminalid?: string;
          virtual_account_number?: string;
          customer?: number;
          amount?: number;
          settlement?: number;
          channel?: "card" | "pos" | "bank" | "dedicated_nuban" | "ussd" | "bank_transfer";
          subaccount_code?: string;
          split_code?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["TransactionListResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Partial Debit
    *
    * Retrieve part of a payment from a customer
     */
    readonly partialDebit: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["TransactionPartialDebit"];
          "application/x-www-form-urlencoded": components["schemas"]["TransactionPartialDebit"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["TransactionPartialDebitResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Get Transaction Session
    *
    * Fetch the session for a specific transaction.
     */
    readonly session: (id: number, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id: number;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["Ok"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Transaction Timeline
    *
    * Fetch the steps taken from the initiation to the completion of a transaction
     */
    readonly timeline: (id_or_reference: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id_or_reference: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["TransactionTimelineResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Transaction Totals
    *
    * Get the total amount of all transactions
     */
    readonly totals: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          perPage?: number;
          page?: number;
          from?: string;
          to?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["TransactionTotalsResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Verify Transaction
    *
    * Verify a previously initiated transaction using it's reference
     */
    readonly verify: (reference: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          reference: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["VerifyResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly transfer: {
    /**
    * Initiate Bulk Transfer
    *
    * Batch multiple transfers in a single request.
    You need to disable the Transfers OTP requirement to use this endpoint.
     */
    readonly bulk: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["TransferBulk"];
          "application/x-www-form-urlencoded": components["schemas"]["TransferBulk"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["TransferBulkResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Disable OTP for Transfers
    *
    * This is used in the event that you want to be able to complete transfers programmatically without use of OTPs.
    No arguments required. You will get an OTP to complete the request.
     */
    readonly disableOtp: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["TransferDisablesOtpResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Finalize Disabling OTP for Transfers
    *
    * Finalize the request to disable OTP on your transfers
     */
    readonly disableOtpFinalize: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["TransferFinalizeDisableOTP"];
          "application/x-www-form-urlencoded": components["schemas"]["TransferFinalizeDisableOTP"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["TransferFinalizeDisablesOtpResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Enable OTP requirement for Transfers
    *
    * In the event that a customer wants to stop being able to complete transfers programmatically, this endpoint helps turn OTP requirement back on.
    No arguments required.
     */
    readonly enableOtp: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["TransferEnablesOtpResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Export Transfers
    *
    * Export a list of transfers carried out on your integration
     */
    readonly exportTransfer: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          recipient?: string;
          status?: "pending" | "success" | "failed" | "otp" | "abandoned" | "reversed" | "blocked" | "rejected" | "received";
          from?: string;
          to?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["Ok"];
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Transfer
    *
    * Get details of a transfer on your integration
     */
    readonly fetch: (id_or_code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id_or_code: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["TransferFetchResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Finalize Transfer
    *
    * Finalize an initiated transfer
     */
    readonly finalize: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["TransferFinalize"];
          "application/x-www-form-urlencoded": components["schemas"]["TransferFinalize"];
        };
      };
      responses: {
        200: components["responses"]["Ok"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Initiate Transfer
    *
    * Send money to your customers
     */
    readonly initiate: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["TransferInitiate"];
          "application/x-www-form-urlencoded": components["schemas"]["TransferInitiate"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["TransferCreateResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Transfers
    *
    * List the transfers made on your integration
     */
    readonly list: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          perPage?: number;
          page?: number;
          from?: string;
          to?: string;
          recipient?: number;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["TransferListResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Resend OTP for Transfer
    *
    * Generates and send a new OTP to customer in the event they are having trouble receiving one.
     */
    readonly resendOtp: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["TransferResendOTP"];
          "application/x-www-form-urlencoded": components["schemas"]["TransferResendOTP"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["TransferResendsOtpResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Verify Transfer
    *
    * Verify the status of a transfer on your integration
     */
    readonly verify: (reference: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          reference: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["TransferVerifyResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly transferrecipient: {
    /**
    * Bulk Create Transfer Recipient
    *
    * Create multiple transfer recipients in batches. A duplicate account number will lead to the retrieval of the existing record.
     */
    readonly bulk: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["TransferRecipientBulk"];
          "application/x-www-form-urlencoded": components["schemas"]["TransferRecipientBulk"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["TransferRecipientBulkCreateResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Create Transfer Recipient
    *
    * Creates a new recipient. A duplicate account number will lead to the retrieval of the existing record.
     */
    readonly create: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["TransferRecipientCreate"];
          "application/x-www-form-urlencoded": components["schemas"]["TransferRecipientCreate"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["TransferRecipientCreateResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Delete Transfer Recipient
    *
    * Delete a transfer recipient (sets the transfer recipient to inactive)
     */
    readonly delete: (id_or_code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id_or_code: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["TransferRecipientDeleteResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Transfer recipient
    *
    * Fetch the details of a transfer recipient
     */
    readonly fetch: (id_or_code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id_or_code: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["TransferRecipientFetchResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Transfer Recipients
    *
    * List transfer recipients available on your integration
     */
    readonly list: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          perPage?: number;
          page?: number;
          from?: string;
          to?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["TransferRecipientListResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Update Transfer Recipient
    *
    * Update the details of a transfer recipient
     */
    readonly update: (id_or_code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          id_or_code: string;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["TransferRecipientUpdate"];
          "application/x-www-form-urlencoded": components["schemas"]["TransferRecipientUpdate"];
        };
      };
      responses: {
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["TransferRecipientUpdateResponse"];
          };
        };
        401: components["responses"]["Unauthorized"];
        404: components["responses"]["NotFound"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
  };
  readonly virtualTerminal: {
    /**
    * Add Split Code to Virtual Terminal
    *
    * Add Split Code to Virtual Terminal
     */
    readonly addSplitCode: (code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          code: string;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["VirtualTerminalAddSplitCode"];
          "application/x-www-form-urlencoded": components["schemas"]["VirtualTerminalAddSplitCode"];
        };
      };
      responses: {
        200: components["responses"]["VirtualTerminalAddSplitCodeSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Create Virtual Terminal
    *
    * Create a Virtual Terminal on your integration
     */
    readonly create: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["VirtualTerminalCreate"];
        };
      };
      responses: {
        200: components["responses"]["VirtualTerminalCreateSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Deactivate Virtual Terminal
    *
    * Deactivate a Virtual Terminal on your integration
     */
    readonly deactivate: (code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          code: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["VirtualTerminalDeactivateSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Remove Split Code from Virtual Terminal
    *
    * Remove Split Code from Virtual Terminal
     */
    readonly deleteSplitCode: (code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          code: string;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["VirtualTerminalDeleteSplitCode"];
          "application/x-www-form-urlencoded": components["schemas"]["VirtualTerminalDeleteSplitCode"];
        };
      };
      responses: {
        200: components["responses"]["VirtualTerminalDeleteSplitCodeSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Assign Destination to Virtual Terminal
    *
    * Add a destination (WhatsApp number) to a Virtual Terminal on your integration
     */
    readonly destinationAssign: (code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          code: string;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["VirtualTerminalDestinationAssign"];
          "application/x-www-form-urlencoded": components["schemas"]["VirtualTerminalDestinationAssign"];
        };
      };
      responses: {
        200: components["responses"]["VirtualTerminalDestinationAssignSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Unassign Destination from Virtual Terminal
    *
    * Unassign a destination (WhatsApp Number) from a Virtual Terminal on your integration
     */
    readonly destinationUnassign: (code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          code: string;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["VirtualTerminalDestinationUnassign"];
          "application/x-www-form-urlencoded": components["schemas"]["VirtualTerminalDestinationUnassign"];
        };
      };
      responses: {
        200: components["responses"]["VirtualTerminalDestinationUnassignSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Fetch Virtual Terminal
    *
    * Fetch a Virtual Terminal on your integration
     */
    readonly fetch: (code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          code: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["VirtualTerminalFetchSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * List Virtual Terminals
    *
    * List Virtual Terminals on your integration
     */
    readonly list: (init?: _$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: {
          status?: "active" | "inactive";
          perPage?: number;
          search?: string;
          next?: string;
          previous?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        200: components["responses"]["VirtualTerminalListSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }> | undefined) => Promise<PaystackResponse<unknown>>;
    /**
    * Update Virtual Terminal
    *
    * Update a Virtual Terminal on your integration
     */
    readonly update: (code: string, init?: Partial<_$openapi_fetch0.FetchOptions<{
      parameters: {
        query?: never;
        header?: never;
        path: {
          code: string;
        };
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["VirtualTerminalUpdate"];
        };
      };
      responses: {
        200: components["responses"]["VirtualTerminalUpdateSuccess"];
        401: components["responses"]["Unauthorized"];
        default: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    }>> | undefined) => Promise<PaystackResponse<unknown>>;
  };
};
//#endregion
//#region src/idempotency.d.ts
declare const DEFAULT_IDEMPOTENCY_HEADER = "Idempotency-Key";
type IdempotencyKeyInput = {
  mode: "none";
} | {
  mode: "static";
  key: string;
} | {
  mode: "auto";
} | {
  mode: "custom";
  generate: () => string;
};
declare function createIdempotencyKey(): string;
declare function hasHeader(headers: HeadersInit | undefined, name: string): boolean;
declare function setHeader(headers: HeadersInit | undefined, name: string, value: string): Headers;
declare function resolveIdempotencyKey(input: IdempotencyKeyInput): string | undefined;
//#endregion
//#region src/types.d.ts
type JsonRequestBody<TOperation> = TOperation extends {
  requestBody?: {
    content: {
      "application/json": infer TBody;
    };
  };
} ? TBody : never;
type JsonResponseBody<TOperation extends {
  responses: Record<PropertyKey, unknown>;
}, TStatus extends keyof TOperation["responses"]> = TOperation["responses"][TStatus] extends {
  content: {
    "application/json": infer TBody;
  };
} ? TBody : never;
type PathParams<TOperation> = TOperation extends {
  parameters: {
    path: infer TPath;
  };
} ? TPath : never;
type QueryParams<TOperation> = TOperation extends {
  parameters: {
    query?: infer TQuery;
  };
} ? TQuery : never;
type SuccessStatus<TResponses extends Record<PropertyKey, unknown>, TPreferred extends PropertyKey = 200> = TPreferred extends keyof TResponses ? TPreferred : Extract<keyof TResponses, 200 | 201 | 202 | 204>;
type JsonSuccessResponseBody<TOperation extends {
  responses: Record<PropertyKey, unknown>;
}, TPreferred extends PropertyKey = 200> = JsonResponseBody<TOperation, SuccessStatus<TOperation["responses"], TPreferred>>;
type PayloadData<TPayload> = TPayload extends {
  data: infer TData;
} ? TData : never;
type PaystackOperations = ReturnType<typeof bindOperations>;
interface Paystack extends PaystackOperations {
  client: PaystackClient;
}
type PaystackTransactionClient = Paystack["transaction"];
type PaystackCustomerClient = Paystack["customer"];
type PaystackSubscriptionClient = Paystack["subscription"];
type PaystackPlanClient = Paystack["plan"];
type PaystackProductClient = Paystack["product"];
type PaystackDisputeClient = Paystack["dispute"];
type PaystackRefundClient = Paystack["refund"];
type TransactionInitializePayload = JsonRequestBody<operations["transaction_initialize"]>;
type TransactionInitializeResponsePayload = JsonSuccessResponseBody<operations["transaction_initialize"]>;
type TransactionInitializeResponseData = TransactionInitializeResponsePayload["data"];
type TransactionChargeAuthorizationPayload = JsonRequestBody<operations["transaction_chargeAuthorization"]>;
type TransactionChargeAuthorizationResponsePayload = JsonSuccessResponseBody<operations["transaction_chargeAuthorization"]>;
type TransactionChargeAuthorizationResponseData = TransactionChargeAuthorizationResponsePayload["data"];
type TransactionVerifyPathParams = PathParams<operations["transaction_verify"]>;
type TransactionVerifyResponsePayload = JsonSuccessResponseBody<operations["transaction_verify"]>;
type TransactionVerifyResponseData = TransactionVerifyResponsePayload["data"];
type ResolveAccountNumberQueryParams = QueryParams<operations["bank_resolveAccountNumber"]>;
type ResolveAccountNumberResponsePayload = JsonSuccessResponseBody<operations["bank_resolveAccountNumber"]>;
type ResolveAccountNumberResponseData = ResolveAccountNumberResponsePayload["data"];
type ValidateAccountNumberPayload = JsonRequestBody<operations["bank_validateAccountNumber"]>;
type ValidateAccountNumberResponsePayload = JsonSuccessResponseBody<operations["bank_validateAccountNumber"]>;
type ValidateAccountNumberResponseData = ValidateAccountNumberResponsePayload["data"];
type ResolveCardBinPathParams = PathParams<operations["miscellaneous_resolveCardBin"]>;
type ResolveCardBinResponsePayload = JsonSuccessResponseBody<operations["miscellaneous_resolveCardBin"]>;
type ResolveCardBinResponseData = ResolveCardBinResponsePayload["data"];
type SubscriptionCreatePayload = JsonRequestBody<operations["subscription_create"]>;
type SubscriptionCreateResponsePayload = JsonSuccessResponseBody<operations["subscription_create"]>;
type SubscriptionCreateResponseData = SubscriptionCreateResponsePayload["data"];
type SubscriptionListQueryParams = QueryParams<operations["subscription_list"]>;
type SubscriptionListResponsePayload = JsonSuccessResponseBody<operations["subscription_list"]>;
type SubscriptionListResponseData = SubscriptionListResponsePayload["data"];
type SubscriptionFetchPathParams = PathParams<operations["subscription_fetch"]>;
type SubscriptionFetchResponsePayload = JsonSuccessResponseBody<operations["subscription_fetch"]>;
type SubscriptionFetchResponseData = SubscriptionFetchResponsePayload["data"];
type SubscriptionDisablePayload = JsonRequestBody<operations["subscription_disable"]>;
type SubscriptionDisableResponsePayload = JsonSuccessResponseBody<operations["subscription_disable"]>;
type SubscriptionDisableResponseData = PayloadData<SubscriptionDisableResponsePayload>;
type SubscriptionEnablePayload = JsonRequestBody<operations["subscription_enable"]>;
type SubscriptionEnableResponsePayload = JsonSuccessResponseBody<operations["subscription_enable"]>;
type SubscriptionEnableResponseData = SubscriptionEnableResponsePayload["data"];
type SubscriptionManageLinkPathParams = PathParams<operations["subscription_manageLink"]>;
type SubscriptionManageLinkResponsePayload = JsonSuccessResponseBody<operations["subscription_manageLink"]>;
type SubscriptionManageLinkResponseData = SubscriptionManageLinkResponsePayload["data"];
type SubscriptionManageEmailPathParams = PathParams<operations["subscription_manageEmail"]>;
type SubscriptionManageEmailResponsePayload = JsonSuccessResponseBody<operations["subscription_manageEmail"]>;
type SubscriptionManageEmailResponseData = SubscriptionManageEmailResponsePayload["data"];
type CustomerCreatePayload = JsonRequestBody<operations["customer_create"]>;
type CustomerCreateResponsePayload = JsonSuccessResponseBody<operations["customer_create"]>;
type CustomerCreateResponseData = CustomerCreateResponsePayload["data"];
type CustomerFetchPathParams = PathParams<operations["customer_fetch"]>;
type CustomerFetchResponsePayload = JsonSuccessResponseBody<operations["customer_fetch"]>;
type CustomerFetchResponseData = CustomerFetchResponsePayload["data"];
type CustomerUpdatePathParams = PathParams<operations["customer_update"]>;
type CustomerUpdatePayload = JsonRequestBody<operations["customer_update"]>;
type CustomerUpdateResponsePayload = JsonSuccessResponseBody<operations["customer_update"]>;
type CustomerUpdateResponseData = CustomerUpdateResponsePayload["data"];
type PlanCreatePayload = JsonRequestBody<operations["plan_create"]>;
type PlanCreateResponsePayload = JsonSuccessResponseBody<operations["plan_create"]>;
type PlanCreateResponseData = PlanCreateResponsePayload["data"];
type PlanListQueryParams = QueryParams<operations["plan_list"]>;
type PlanListResponsePayload = JsonSuccessResponseBody<operations["plan_list"]>;
type PlanListResponseData = PlanListResponsePayload["data"];
type PlanFetchPathParams = PathParams<operations["plan_fetch"]>;
type PlanFetchResponsePayload = JsonSuccessResponseBody<operations["plan_fetch"]>;
type PlanFetchResponseData = PlanFetchResponsePayload["data"];
type PlanUpdatePathParams = PathParams<operations["plan_update"]>;
type PlanUpdatePayload = JsonRequestBody<operations["plan_update"]>;
type PlanUpdateResponsePayload = JsonSuccessResponseBody<operations["plan_update"]>;
type PlanUpdateResponseData = PayloadData<PlanUpdateResponsePayload>;
type ProductCreatePayload = JsonRequestBody<operations["product_create"]>;
type ProductCreateResponsePayload = JsonSuccessResponseBody<operations["product_create"]>;
type ProductCreateResponseData = ProductCreateResponsePayload["data"];
type ProductListQueryParams = QueryParams<operations["product_list"]>;
type ProductListResponsePayload = JsonSuccessResponseBody<operations["product_list"]>;
type ProductListResponseData = ProductListResponsePayload["data"];
type ProductFetchPathParams = PathParams<operations["product_fetch"]>;
type ProductFetchResponsePayload = JsonSuccessResponseBody<operations["product_fetch"]>;
type ProductFetchResponseData = ProductFetchResponsePayload["data"];
type ProductUpdatePathParams = PathParams<operations["product_update"]>;
type ProductUpdatePayload = JsonRequestBody<operations["product_update"]>;
type ProductUpdateResponsePayload = JsonSuccessResponseBody<operations["product_update"]>;
type ProductUpdateResponseData = ProductUpdateResponsePayload["data"];
type DisputeListQueryParams = QueryParams<operations["dispute_list"]>;
type DisputeListResponsePayload = JsonSuccessResponseBody<operations["dispute_list"]>;
type DisputeListResponseData = DisputeListResponsePayload["data"];
type DisputeFetchPathParams = PathParams<operations["dispute_fetch"]>;
type DisputeFetchResponsePayload = JsonSuccessResponseBody<operations["dispute_fetch"]>;
type DisputeFetchResponseData = DisputeFetchResponsePayload["data"];
type RefundCreatePayload = JsonRequestBody<operations["refund_create"]>;
type RefundCreateResponsePayload = JsonSuccessResponseBody<operations["refund_create"]>;
type RefundCreateResponseData = RefundCreateResponsePayload["data"];
type RefundFetchPathParams = PathParams<operations["refund_fetch"]>;
type RefundFetchResponsePayload = JsonSuccessResponseBody<operations["refund_fetch"]>;
type RefundFetchResponseData = RefundFetchResponsePayload["data"];
type SplitFetchPathParams = PathParams<operations["split_fetch"]>;
type SplitFetchResponsePayload = JsonSuccessResponseBody<operations["split_fetch"]>;
type SplitFetchResponseData = SplitFetchResponsePayload["data"];
type SubaccountCreatePayload = JsonRequestBody<operations["subaccount_create"]>;
type SubaccountCreateResponsePayload = JsonSuccessResponseBody<operations["subaccount_create"]>;
type SubaccountCreateResponseData = SubaccountCreateResponsePayload["data"];
type SubaccountFetchPathParams = PathParams<operations["subaccount_fetch"]>;
type SubaccountFetchResponsePayload = JsonSuccessResponseBody<operations["subaccount_fetch"]>;
type SubaccountFetchResponseData = SubaccountFetchResponsePayload["data"];
type TerminalFetchPathParams = PathParams<operations["terminal_fetch"]>;
type TerminalFetchResponsePayload = JsonSuccessResponseBody<operations["terminal_fetch"]>;
type TerminalFetchResponseData = TerminalFetchResponsePayload["data"];
type TerminalSendEventPathParams = PathParams<operations["terminal_sendEvent"]>;
type TerminalSendEventPayload = JsonRequestBody<operations["terminal_sendEvent"]>;
type TerminalSendEventResponsePayload = JsonSuccessResponseBody<operations["terminal_sendEvent"]>;
type TerminalSendEventResponseData = TerminalSendEventResponsePayload["data"];
type VirtualTerminalFetchPathParams = PathParams<operations["virtualTerminal_fetch"]>;
type VirtualTerminalFetchResponsePayload = JsonSuccessResponseBody<operations["virtualTerminal_fetch"]>;
type VirtualTerminalFetchResponseData = VirtualTerminalFetchResponsePayload["data"];
type PaymentRequestCreatePayload = JsonRequestBody<operations["paymentRequest_create"]>;
type PaymentRequestCreateResponsePayload = JsonSuccessResponseBody<operations["paymentRequest_create"]>;
type PaymentRequestCreateResponseData = PaymentRequestCreateResponsePayload["data"];
type PaymentRequestFetchPathParams = PathParams<operations["paymentRequest_fetch"]>;
type PaymentRequestFetchResponsePayload = JsonSuccessResponseBody<operations["paymentRequest_fetch"]>;
type PaymentRequestFetchResponseData = PaymentRequestFetchResponsePayload["data"];
//#endregion
//#region src/index.d.ts
declare function createPaystack(options: PaystackClientOptions): Paystack;
//#endregion
export { CustomerCreatePayload, CustomerCreateResponseData, CustomerCreateResponsePayload, CustomerFetchPathParams, CustomerFetchResponseData, CustomerFetchResponsePayload, CustomerUpdatePathParams, CustomerUpdatePayload, CustomerUpdateResponseData, CustomerUpdateResponsePayload, DEFAULT_IDEMPOTENCY_HEADER, DEFAULT_REQUEST_ID_HEADERS, DisputeFetchPathParams, DisputeFetchResponseData, DisputeFetchResponsePayload, DisputeListQueryParams, DisputeListResponseData, DisputeListResponsePayload, IdempotencyKeyInput, PaymentNotificationWebhookEvent, PaymentRequestCreatePayload, PaymentRequestCreateResponseData, PaymentRequestCreateResponsePayload, PaymentRequestFetchPathParams, PaymentRequestFetchResponseData, PaymentRequestFetchResponsePayload, Paystack, PaystackApiError, PaystackClient, PaystackClientOptions, PaystackCustomerClient, PaystackDisputeClient, PaystackError, PaystackErrorOptions, PaystackErrorType, PaystackOperations, PaystackPaths, PaystackPlanClient, PaystackProductClient, PaystackRawResponse, PaystackRefundClient, PaystackResponse, PaystackRetryOptions, PaystackSubscriptionClient, PaystackTransactionClient, PaystackWebhookEvent, PlanCreatePayload, PlanCreateResponseData, PlanCreateResponsePayload, PlanFetchPathParams, PlanFetchResponseData, PlanFetchResponsePayload, PlanListQueryParams, PlanListResponseData, PlanListResponsePayload, PlanUpdatePathParams, PlanUpdatePayload, PlanUpdateResponseData, PlanUpdateResponsePayload, ProductCreatePayload, ProductCreateResponseData, ProductCreateResponsePayload, ProductFetchPathParams, ProductFetchResponseData, ProductFetchResponsePayload, ProductListQueryParams, ProductListResponseData, ProductListResponsePayload, ProductUpdatePathParams, ProductUpdatePayload, ProductUpdateResponseData, ProductUpdateResponsePayload, RefundCreatePayload, RefundCreateResponseData, RefundCreateResponsePayload, RefundFetchPathParams, RefundFetchResponseData, RefundFetchResponsePayload, ResolveAccountNumberQueryParams, ResolveAccountNumberResponseData, ResolveAccountNumberResponsePayload, ResolveCardBinPathParams, ResolveCardBinResponseData, ResolveCardBinResponsePayload, SplitFetchPathParams, SplitFetchResponseData, SplitFetchResponsePayload, SubaccountCreatePayload, SubaccountCreateResponseData, SubaccountCreateResponsePayload, SubaccountFetchPathParams, SubaccountFetchResponseData, SubaccountFetchResponsePayload, SubscriptionCreatePayload, SubscriptionCreateResponseData, SubscriptionCreateResponsePayload, SubscriptionDisablePayload, SubscriptionDisableResponseData, SubscriptionDisableResponsePayload, SubscriptionEnablePayload, SubscriptionEnableResponseData, SubscriptionEnableResponsePayload, SubscriptionFetchPathParams, SubscriptionFetchResponseData, SubscriptionFetchResponsePayload, SubscriptionListQueryParams, SubscriptionListResponseData, SubscriptionListResponsePayload, SubscriptionManageEmailPathParams, SubscriptionManageEmailResponseData, SubscriptionManageEmailResponsePayload, SubscriptionManageLinkPathParams, SubscriptionManageLinkResponseData, SubscriptionManageLinkResponsePayload, TerminalFetchPathParams, TerminalFetchResponseData, TerminalFetchResponsePayload, TerminalSendEventPathParams, TerminalSendEventPayload, TerminalSendEventResponseData, TerminalSendEventResponsePayload, TransactionChargeAuthorizationPayload, TransactionChargeAuthorizationResponseData, TransactionChargeAuthorizationResponsePayload, TransactionInitializePayload, TransactionInitializeResponseData, TransactionInitializeResponsePayload, TransactionVerifyPathParams, TransactionVerifyResponseData, TransactionVerifyResponsePayload, ValidateAccountNumberPayload, ValidateAccountNumberResponseData, ValidateAccountNumberResponsePayload, VirtualTerminalFetchPathParams, VirtualTerminalFetchResponseData, VirtualTerminalFetchResponsePayload, Webhooks, applePay_listDomain, applePay_registerDomain, applePay_unregisterDomain, assertOk, balance_fetch, balance_ledger, bank_list, bank_resolveAccountNumber, bank_validateAccountNumber, bindOperations, bulkCharge_charges, bulkCharge_fetch, bulkCharge_initiate, bulkCharge_list, bulkCharge_pause, bulkCharge_resume, capitecPay_requery, charge_check, charge_create, charge_submitAddress, charge_submitBirthday, charge_submitOtp, charge_submitPhone, charge_submitPin, type components, createIdempotencyKey, createPaystack, createPaystackClient, customer_create, customer_deactivateAuthorization, customer_directDebitActivationCharge, customer_fetch, customer_fetchMandateAuthorizations, customer_initializeAuthorization, customer_initializeDirectDebit, customer_list, customer_riskAction, customer_update, customer_validate, customer_verifyAuthorization, dedicatedAccount_addSplit, dedicatedAccount_assign, dedicatedAccount_availableProviders, dedicatedAccount_create, dedicatedAccount_deactivate, dedicatedAccount_fetch, dedicatedAccount_list, dedicatedAccount_removeSplit, dedicatedAccount_requery, directdebit_listMandateAuthorizations, directdebit_triggerActivationCharge, dispute_download, dispute_evidence, dispute_fetch, dispute_list, dispute_resolve, dispute_transaction, dispute_update, dispute_uploadUrl, getPaystackRequestId, hasHeader, integration_fetchPaymentSessionTimeout, integration_updatePaymentSessionTimeout, isPaystackApiError, misc_generateWebhookEventTypes, miscellaneous_avs, miscellaneous_listCountries, miscellaneous_resolveCardBin, type operations, order_create, order_fetch, order_list, order_product, order_validate, page_addProducts, page_checkSlugAvailability, page_create, page_fetch, page_list, page_update, type paths, paymentRequest_archive, paymentRequest_create, paymentRequest_fetch, paymentRequest_finalize, paymentRequest_list, paymentRequest_notify, paymentRequest_totals, paymentRequest_update, paymentRequest_verify, plan_create, plan_fetch, plan_list, plan_update, preauthorization_capture, preauthorization_initialize, preauthorization_list, preauthorization_release, preauthorization_reserve_authorization, preauthorization_verify, product_create, product_delete, product_fetch, product_list, product_update, refund_create, refund_fetch, refund_list, refund_retry, resolveIdempotencyKey, setHeader, settlements_fetch, settlements_transaction, split_addSubaccount, split_create, split_fetch, split_list, split_removeSubaccount, split_update, storefront_addProducts, storefront_create, storefront_delete, storefront_duplicate, storefront_fetch, storefront_fetchOrders, storefront_list, storefront_listProducts, storefront_publish, storefront_update, storefront_verifySlug, subaccount_create, subaccount_fetch, subaccount_list, subaccount_update, subscription_create, subscription_disable, subscription_enable, subscription_fetch, subscription_list, subscription_manageEmail, subscription_manageLink, terminal_commission, terminal_decommission, terminal_fetch, terminal_fetchEventStatus, terminal_fetchTerminalStatus, terminal_list, terminal_sendEvent, terminal_update, toPaystackApiError, transaction_chargeAuthorization, transaction_checkAuthorization, transaction_event, transaction_export, transaction_fetch, transaction_initialize, transaction_list, transaction_partialDebit, transaction_session, transaction_timeline, transaction_totals, transaction_verify, transfer_bulk, transfer_disableOtp, transfer_disableOtpFinalize, transfer_enableOtp, transfer_exportTransfer, transfer_fetch, transfer_finalize, transfer_initiate, transfer_list, transfer_resendOtp, transfer_verify, transferrecipient_bulk, transferrecipient_create, transferrecipient_delete, transferrecipient_fetch, transferrecipient_list, transferrecipient_update, virtualTerminal_addSplitCode, virtualTerminal_create, virtualTerminal_deactivate, virtualTerminal_deleteSplitCode, virtualTerminal_destinationAssign, virtualTerminal_destinationUnassign, virtualTerminal_fetch, virtualTerminal_list, virtualTerminal_update };