rehive 4.2.2 → 4.4.0

package/dist/extensions/mukuru.d.mts

@@ -0,0 +1,1220 @@
+import { A as ApiFactoryConfig, B as BoundSdk } from '../create-api-client-BY6W7Qz9.mjs';
+import '../create-auth-CROjq_cP.mjs';
+
+type AuthToken = string | undefined;
+interface Auth {
+    /**
+     * Which part of the request do we use to send the auth?
+     *
+     * @default 'header'
+     */
+    in?: 'header' | 'query' | 'cookie';
+    /**
+     * A unique identifier for the security scheme.
+     *
+     * Defined only when there are multiple security schemes whose `Auth`
+     * shape would otherwise be identical.
+     */
+    key?: string;
+    /**
+     * Header or query parameter name.
+     *
+     * @default 'Authorization'
+     */
+    name?: string;
+    scheme?: 'basic' | 'bearer';
+    type: 'apiKey' | 'http';
+}
+
+interface SerializerOptions<T> {
+    /**
+     * @default true
+     */
+    explode: boolean;
+    style: T;
+}
+type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
+type ObjectStyle = 'form' | 'deepObject';
+
+type QuerySerializer = (query: Record<string, unknown>) => string;
+type BodySerializer = (body: unknown) => unknown;
+type QuerySerializerOptionsObject = {
+    allowReserved?: boolean;
+    array?: Partial<SerializerOptions<ArrayStyle>>;
+    object?: Partial<SerializerOptions<ObjectStyle>>;
+};
+type QuerySerializerOptions = QuerySerializerOptionsObject & {
+    /**
+     * Per-parameter serialization overrides. When provided, these settings
+     * override the global array/object settings for specific parameter names.
+     */
+    parameters?: Record<string, QuerySerializerOptionsObject>;
+};
+
+type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+type Client$1<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
+    /**
+     * Returns the final request URL.
+     */
+    buildUrl: BuildUrlFn;
+    getConfig: () => Config;
+    request: RequestFn;
+    setConfig: (config: Config) => Config;
+} & {
+    [K in HttpMethod]: MethodFn;
+} & ([SseFn] extends [never] ? {
+    sse?: never;
+} : {
+    sse: {
+        [K in HttpMethod]: SseFn;
+    };
+});
+interface Config$1 {
+    /**
+     * Auth token or a function returning auth token. The resolved value will be
+     * added to the request payload as defined by its `security` array.
+     */
+    auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+    /**
+     * A function for serializing request body parameter. By default,
+     * {@link JSON.stringify()} will be used.
+     */
+    bodySerializer?: BodySerializer | null;
+    /**
+     * An object containing any HTTP headers that you want to pre-populate your
+     * `Headers` object with.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+     */
+    headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
+    /**
+     * The request method.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+     */
+    method?: Uppercase<HttpMethod>;
+    /**
+     * A function for serializing request query parameters. By default, arrays
+     * will be exploded in form style, objects will be exploded in deepObject
+     * style, and reserved characters are percent-encoded.
+     *
+     * This method will have no effect if the native `paramsSerializer()` Axios
+     * API function is used.
+     *
+     * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+     */
+    querySerializer?: QuerySerializer | QuerySerializerOptions;
+    /**
+     * A function validating request data. This is useful if you want to ensure
+     * the request conforms to the desired shape, so it can be safely sent to
+     * the server.
+     */
+    requestValidator?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function transforming response data before it's returned. This is useful
+     * for post-processing data, e.g., converting ISO strings into Date objects.
+     */
+    responseTransformer?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function validating response data. This is useful if you want to ensure
+     * the response conforms to the desired shape, so it can be safely passed to
+     * the transformers and returned to the user.
+     */
+    responseValidator?: (data: unknown) => Promise<unknown>;
+}
+/**
+ * Arbitrary metadata passed through the `meta` request option.
+ */
+interface ClientMeta {
+}
+
+type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config$1, 'method' | 'responseTransformer' | 'responseValidator'> & {
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Implementing clients can call request interceptors inside this hook.
+     */
+    onRequest?: (url: string, init: RequestInit) => Promise<Request>;
+    /**
+     * Callback invoked when a network or parsing error occurs during streaming.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param error The error that occurred.
+     */
+    onSseError?: (error: unknown) => void;
+    /**
+     * Callback invoked when an event is streamed from the server.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param event Event streamed from the server.
+     * @returns Nothing (void).
+     */
+    onSseEvent?: (event: StreamEvent<TData>) => void;
+    serializedBody?: RequestInit['body'];
+    /**
+     * Default retry delay in milliseconds.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 3000
+     */
+    sseDefaultRetryDelay?: number;
+    /**
+     * Maximum number of retry attempts before giving up.
+     */
+    sseMaxRetryAttempts?: number;
+    /**
+     * Maximum retry delay in milliseconds.
+     *
+     * Applies only when exponential backoff is used.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 30000
+     */
+    sseMaxRetryDelay?: number;
+    /**
+     * Optional sleep function for retry backoff.
+     *
+     * Defaults to using `setTimeout`.
+     */
+    sseSleepFn?: (ms: number) => Promise<void>;
+    url: string;
+};
+interface StreamEvent<TData = unknown> {
+    data: TData;
+    event?: string;
+    id?: string;
+    retry?: number;
+}
+type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
+    stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
+};
+
+type ErrInterceptor<Err, Res, Req, Options> = (error: Err, 
+/** response may be undefined due to a network error where no response object is produced */
+response: Res | undefined, 
+/** request may be undefined, because error may be from building the request object itself */
+request: Req | undefined, options: Options) => Err | Promise<Err>;
+type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
+type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
+declare class Interceptors<Interceptor> {
+    fns: Array<Interceptor | null>;
+    clear(): void;
+    eject(id: number | Interceptor): void;
+    exists(id: number | Interceptor): boolean;
+    getInterceptorIndex(id: number | Interceptor): number;
+    update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
+    use(fn: Interceptor): number;
+}
+interface Middleware<Req, Res, Err, Options> {
+    error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
+    request: Interceptors<ReqInterceptor<Req, Options>>;
+    response: Interceptors<ResInterceptor<Res, Req, Options>>;
+}
+
+type ResponseStyle = 'data' | 'fields';
+interface Config<T extends ClientOptions$1 = ClientOptions$1> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$1 {
+    /**
+     * Base URL for all requests made by this client.
+     */
+    baseUrl?: T['baseUrl'];
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Please don't use the Fetch client for Next.js applications. The `next`
+     * options won't have any effect.
+     *
+     * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
+     */
+    next?: never;
+    /**
+     * Return the response data parsed in a specified format. By default, `auto`
+     * will infer the appropriate method from the `Content-Type` response header.
+     * You can override this behavior with any of the {@link Body} methods.
+     * Select `stream` if you don't want to parse response data at all.
+     *
+     * @default 'auto'
+     */
+    parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
+    /**
+     * Should we return only data or multiple fields (data, error, response, etc.)?
+     *
+     * @default 'fields'
+     */
+    responseStyle?: ResponseStyle;
+    /**
+     * Throw an error instead of returning it in the response?
+     *
+     * @default false
+     */
+    throwOnError?: T['throwOnError'];
+}
+interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = 'data', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
+    responseStyle: TResponseStyle;
+    throwOnError: ThrowOnError;
+}>, Pick<ServerSentEventsOptions<TData>, 'onRequest' | 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+    /**
+     * Any body that you want to add to your request.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+     */
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    /**
+     * Security mechanism(s) to use for the request.
+     */
+    security?: ReadonlyArray<Auth>;
+    url: Url;
+}
+interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'data', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+    headers: Headers;
+    serializedBody?: string;
+}
+type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'data'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    request: Request;
+    response: Response;
+}> : Promise<TResponseStyle extends 'data' ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    error: undefined;
+} | {
+    data: undefined;
+    error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
+}) & {
+    /** request may be undefined, because error may be from building the request object itself */
+    request?: Request;
+    /** response may be undefined, because error may be from building the request object itself or from a network error */
+    response?: Response;
+}>;
+interface ClientOptions$1 {
+    baseUrl?: string;
+    responseStyle?: ResponseStyle;
+    throwOnError?: boolean;
+}
+type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'data'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type SseFn = <TData = unknown, _TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'data'>(options: Omit<RequestOptions<never, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData>>;
+type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'data'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type BuildUrlFn = <TData extends {
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    url: string;
+}>(options: TData & Options$1<TData>) => string;
+type Client = Client$1<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
+    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+};
+interface TDataShape {
+    body?: unknown;
+    headers?: unknown;
+    path?: unknown;
+    query?: unknown;
+    url: string;
+}
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+type Options$1<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = 'data'> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
+
+type ClientOptions = {
+    baseUrl: 'https://mukuru.services.rehive.com/' | (string & {});
+};
+/**
+ * This serializer can be used if only a `status` is required in the response.
+ */
+type ActionResponse = {
+    status: string;
+};
+/**
+ * Serialize the activation data, should be a token that represents an admin
+ * user.
+ */
+type Activate = {
+    token: string;
+    readonly id: string;
+    readonly name: string;
+    readonly secret: string;
+};
+/**
+ * A ModelSerializer that takes additional arguments for
+ * "fields", "omit" and "expand" in order to
+ * control which fields are displayed, and whether to replace simple
+ * values with complex, nested serializations
+ */
+type AdminCompany = {
+    readonly id: string;
+    readonly secret: string;
+    readonly name: string;
+    /**
+     * * `test` - Test
+     * * `production` - Production
+     */
+    readonly mode: 'test' | 'production';
+    mukuru_keycloak_client_id?: string;
+    readonly mukuru_keycloak_client_secret: string;
+    mukuru_keycloak_token_url?: string;
+    mukuru_base_url?: string;
+    mukuru_operational_address?: string;
+    /**
+     * * `base` - Base
+     */
+    mukuru_chain?: 'base';
+    readonly mukuru_callback_password: string;
+    business_sender_first_name?: string;
+    business_sender_last_name?: string;
+    business_sender_street_address?: string;
+    business_sender_city?: string;
+    business_sender_region?: string;
+    business_sender_postal_code?: string;
+    business_sender_country_code?: string;
+    readonly configured: boolean;
+};
+type AdminCompanyResponse = {
+    status: string;
+    data: AdminCompany;
+};
+/**
+ * Per-company Mukuru payout product, configurable by company admins via
+ * `/api/admin/products/`. Lets clients self-configure their own catalog
+ * (production GUIDs differ per environment) instead of relying on the
+ * `seed_mukuru_products` sandbox management command.
+ *
+ * `company` is never client-supplied — it's taken from the authenticated
+ * admin's company in the view. Uniqueness of (company, payment_method) is
+ * enforced here (cleanly, as a 400) on top of the model's
+ * unique_together, so duplicate POSTs don't surface as a 500.
+ */
+type AdminMukuruProduct = {
+    payment_method: string;
+    product_guid: string;
+    country_code: string;
+    payout_currency: string;
+    settlement_currency?: string;
+    min_payout_amount?: string | null;
+    max_payout_amount?: string | null;
+    active?: boolean;
+    readonly created: string;
+    readonly updated: string;
+};
+type AdminMukuruProductResponse = {
+    status: string;
+    data: AdminMukuruProduct;
+};
+/**
+ * A ModelSerializer that takes additional arguments for
+ * "fields", "omit" and "expand" in order to
+ * control which fields are displayed, and whether to replace simple
+ * values with complex, nested serializations
+ */
+type AdminMukuruTransaction = {
+    readonly id: string;
+    readonly rehive_transaction_id: string;
+    readonly mukuru_external_reference: string;
+    /**
+     * * `pending` - Pending
+     * * `ready` - Ready
+     * * `paid` - Paid
+     * * `received` - Received
+     * * `successful` - Successful
+     * * `cancelled` - Cancelled
+     * * `refunded` - Refunded
+     * * `failed` - Failed
+     * * `kyc_failed` - Kyc Failed
+     * * `insufficient_funds` - Insufficient Funds
+     */
+    readonly mukuru_status: 'pending' | 'ready' | 'paid' | 'received' | 'successful' | 'cancelled' | 'refunded' | 'failed' | 'kyc_failed' | 'insufficient_funds';
+    readonly rehive_secondary_status: string;
+    readonly terminated_at: string | null;
+    readonly recipient_mobile: string;
+    readonly created: string;
+    readonly updated: string;
+    readonly mukuru_payload: unknown;
+};
+type AdminMukuruTransactionResponse = {
+    status: string;
+    data: AdminMukuruTransaction;
+};
+/**
+ * One Mukuru operational ("clearing") balance, in MAJOR currency units.
+ */
+type AdminOperationalAccount = {
+    currency: string;
+    available: string;
+};
+/**
+ * Response for GET /api/admin/operational-accounts/ — the partner's
+ * operational float held at the Mukuru aggregator, per currency, plus the
+ * time it was fetched.
+ */
+type AdminOperationalAccounts = {
+    accounts: Array<AdminOperationalAccount>;
+    as_of: string;
+};
+/**
+ * Write variant of `AdminCompanySerializer` used for PATCH/PUT. Secrets
+ * are writable here (plain CharFields) but marked write-only so the
+ * PATCH response can't leak the plaintext the admin just sent — the
+ * dashboard refetches via GET to display the masked values.
+ */
+type AdminUpdateCompany = {
+    readonly id: string;
+    readonly secret: string;
+    readonly name: string;
+    /**
+     * * `test` - Test
+     * * `production` - Production
+     */
+    readonly mode: 'test' | 'production';
+    mukuru_keycloak_client_id?: string;
+    mukuru_keycloak_token_url?: string;
+    mukuru_base_url?: string;
+    mukuru_operational_address?: string;
+    /**
+     * * `base` - Base
+     */
+    mukuru_chain?: 'base';
+    business_sender_first_name?: string;
+    business_sender_last_name?: string;
+    business_sender_street_address?: string;
+    business_sender_city?: string;
+    business_sender_region?: string;
+    business_sender_postal_code?: string;
+    business_sender_country_code?: string;
+    readonly configured: boolean;
+};
+/**
+ * A ModelSerializer that takes additional arguments for
+ * "fields", "omit" and "expand" in order to
+ * control which fields are displayed, and whether to replace simple
+ * values with complex, nested serializations
+ */
+type AdminUser = {
+    readonly id: string;
+    readonly created: string;
+    readonly updated: string;
+};
+/**
+ * Serialize the deactivation data, should be a token that represents an admin
+ * user.
+ */
+type Deactivate = {
+    token: string;
+    purge?: boolean;
+};
+type PaginatedAdminMukuruProductList = {
+    count: number;
+    next?: string | null;
+    previous?: string | null;
+    results: Array<AdminMukuruProduct>;
+};
+type PaginatedAdminMukuruProductListResponse = {
+    status: string;
+    data: PaginatedAdminMukuruProductList;
+};
+type PaginatedAdminMukuruTransactionList = {
+    count: number;
+    next?: string | null;
+    previous?: string | null;
+    results: Array<AdminMukuruTransaction>;
+};
+type PaginatedAdminMukuruTransactionListResponse = {
+    status: string;
+    data: PaginatedAdminMukuruTransactionList;
+};
+type PaginatedAdminUserList = {
+    count: number;
+    next?: string | null;
+    previous?: string | null;
+    results: Array<AdminUser>;
+};
+type PaginatedAdminUserListResponse = {
+    status: string;
+    data: PaginatedAdminUserList;
+};
+type PaginatedUserMukuruTransactionList = {
+    count: number;
+    next?: string | null;
+    previous?: string | null;
+    results: Array<UserMukuruTransaction>;
+};
+type PaginatedUserMukuruTransactionListResponse = {
+    status: string;
+    data: PaginatedUserMukuruTransactionList;
+};
+/**
+ * Per-company Mukuru payout product, configurable by company admins via
+ * `/api/admin/products/`. Lets clients self-configure their own catalog
+ * (production GUIDs differ per environment) instead of relying on the
+ * `seed_mukuru_products` sandbox management command.
+ *
+ * `company` is never client-supplied — it's taken from the authenticated
+ * admin's company in the view. Uniqueness of (company, payment_method) is
+ * enforced here (cleanly, as a 400) on top of the model's
+ * unique_together, so duplicate POSTs don't surface as a 500.
+ */
+type PatchedAdminMukuruProduct = {
+    payment_method?: string;
+    product_guid?: string;
+    country_code?: string;
+    payout_currency?: string;
+    settlement_currency?: string;
+    min_payout_amount?: string | null;
+    max_payout_amount?: string | null;
+    active?: boolean;
+    readonly created?: string;
+    readonly updated?: string;
+};
+/**
+ * Write variant of `AdminCompanySerializer` used for PATCH/PUT. Secrets
+ * are writable here (plain CharFields) but marked write-only so the
+ * PATCH response can't leak the plaintext the admin just sent — the
+ * dashboard refetches via GET to display the masked values.
+ */
+type PatchedAdminUpdateCompany = {
+    readonly id?: string;
+    readonly secret?: string;
+    readonly name?: string;
+    /**
+     * * `test` - Test
+     * * `production` - Production
+     */
+    readonly mode?: 'test' | 'production';
+    mukuru_keycloak_client_id?: string;
+    mukuru_keycloak_token_url?: string;
+    mukuru_base_url?: string;
+    mukuru_operational_address?: string;
+    /**
+     * * `base` - Base
+     */
+    mukuru_chain?: 'base';
+    business_sender_first_name?: string;
+    business_sender_last_name?: string;
+    business_sender_street_address?: string;
+    business_sender_city?: string;
+    business_sender_region?: string;
+    business_sender_postal_code?: string;
+    business_sender_country_code?: string;
+    readonly configured?: boolean;
+};
+/**
+ * A ModelSerializer that takes additional arguments for
+ * "fields", "omit" and "expand" in order to
+ * control which fields are displayed, and whether to replace simple
+ * values with complex, nested serializations
+ */
+type UserMukuruTransaction = {
+    readonly id: string;
+    readonly rehive_transaction_id: string;
+    readonly mukuru_external_reference: string;
+    /**
+     * * `pending` - Pending
+     * * `ready` - Ready
+     * * `paid` - Paid
+     * * `received` - Received
+     * * `successful` - Successful
+     * * `cancelled` - Cancelled
+     * * `refunded` - Refunded
+     * * `failed` - Failed
+     * * `kyc_failed` - Kyc Failed
+     * * `insufficient_funds` - Insufficient Funds
+     */
+    readonly mukuru_status: 'pending' | 'ready' | 'paid' | 'received' | 'successful' | 'cancelled' | 'refunded' | 'failed' | 'kyc_failed' | 'insufficient_funds';
+    readonly rehive_secondary_status: string;
+    readonly terminated_at: string | null;
+    readonly recipient_mobile: string;
+    readonly created: string;
+    readonly updated: string;
+};
+type UserMukuruTransactionResponse = {
+    status: string;
+    data: UserMukuruTransaction;
+};
+/**
+ * Verifies an inbound Rehive Platform webhook.
+ *
+ * Authenticates by comparing the `Authorization: secret <UUID>` header
+ * against the company's stored secret — the secret we register on each
+ * webhook subscription during activate. Mirrors the canonical pattern
+ * used by service-hifi (serializers.py:332) and service-bridge
+ * (serializers.py:564); see also the plan §"Platform webhook
+ * orchestration".
+ *
+ * Idempotency: PlatformWebhook.identifier is set to Rehive's webhook
+ * delivery UUID, so duplicate deliveries collide on the unique
+ * constraint and become a silent no-op (Rehive retries on non-2xx).
+ */
+type Webhook = {
+    id: string;
+    /**
+     * * `transaction.update` - Transaction Update
+     * * `transaction.initiate` - Transaction Initiate
+     * * `transaction.transition.update` - Transaction Transition Update
+     * * `user.update` - User Update
+     * * `wallet_account.create` - Wallet Account Create
+     * * `wallet_account.update` - Wallet Account Update
+     * * `wallet_account.delete` - Wallet Account Delete
+     */
+    event: 'transaction.update' | 'transaction.initiate' | 'transaction.transition.update' | 'user.update' | 'wallet_account.create' | 'wallet_account.update' | 'wallet_account.delete';
+    company: string;
+    data: unknown;
+};
+/**
+ * A ModelSerializer that takes additional arguments for
+ * "fields", "omit" and "expand" in order to
+ * control which fields are displayed, and whether to replace simple
+ * values with complex, nested serializations
+ */
+type AdminCompanyWritable = {
+    mukuru_keycloak_client_id?: string;
+    mukuru_keycloak_token_url?: string;
+    mukuru_base_url?: string;
+    mukuru_operational_address?: string;
+    /**
+     * * `base` - Base
+     */
+    mukuru_chain?: 'base';
+    business_sender_first_name?: string;
+    business_sender_last_name?: string;
+    business_sender_street_address?: string;
+    business_sender_city?: string;
+    business_sender_region?: string;
+    business_sender_postal_code?: string;
+    business_sender_country_code?: string;
+};
+type AdminCompanyResponseWritable = {
+    status: string;
+    data: AdminCompanyWritable;
+};
+/**
+ * Per-company Mukuru payout product, configurable by company admins via
+ * `/api/admin/products/`. Lets clients self-configure their own catalog
+ * (production GUIDs differ per environment) instead of relying on the
+ * `seed_mukuru_products` sandbox management command.
+ *
+ * `company` is never client-supplied — it's taken from the authenticated
+ * admin's company in the view. Uniqueness of (company, payment_method) is
+ * enforced here (cleanly, as a 400) on top of the model's
+ * unique_together, so duplicate POSTs don't surface as a 500.
+ */
+type AdminMukuruProductWritable = {
+    payment_method: string;
+    product_guid: string;
+    country_code: string;
+    payout_currency: string;
+    settlement_currency?: string;
+    min_payout_amount?: string | null;
+    max_payout_amount?: string | null;
+    active?: boolean;
+};
+type AdminMukuruProductResponseWritable = {
+    status: string;
+    data: AdminMukuruProductWritable;
+};
+type AdminMukuruTransactionResponseWritable = {
+    status: string;
+};
+/**
+ * Write variant of `AdminCompanySerializer` used for PATCH/PUT. Secrets
+ * are writable here (plain CharFields) but marked write-only so the
+ * PATCH response can't leak the plaintext the admin just sent — the
+ * dashboard refetches via GET to display the masked values.
+ */
+type AdminUpdateCompanyWritable = {
+    mukuru_keycloak_client_id?: string;
+    mukuru_keycloak_client_secret?: string;
+    mukuru_keycloak_token_url?: string;
+    mukuru_base_url?: string;
+    mukuru_operational_address?: string;
+    /**
+     * * `base` - Base
+     */
+    mukuru_chain?: 'base';
+    mukuru_callback_password?: string;
+    business_sender_first_name?: string;
+    business_sender_last_name?: string;
+    business_sender_street_address?: string;
+    business_sender_city?: string;
+    business_sender_region?: string;
+    business_sender_postal_code?: string;
+    business_sender_country_code?: string;
+};
+type PaginatedAdminMukuruProductListWritable = {
+    count: number;
+    next?: string | null;
+    previous?: string | null;
+    results: Array<AdminMukuruProductWritable>;
+};
+type PaginatedAdminMukuruProductListResponseWritable = {
+    status: string;
+    data: PaginatedAdminMukuruProductListWritable;
+};
+type PaginatedAdminMukuruTransactionListWritable = {
+    count: number;
+    next?: string | null;
+    previous?: string | null;
+    results: Array<unknown>;
+};
+type PaginatedAdminMukuruTransactionListResponseWritable = {
+    status: string;
+    data: PaginatedAdminMukuruTransactionListWritable;
+};
+type PaginatedAdminUserListWritable = {
+    count: number;
+    next?: string | null;
+    previous?: string | null;
+    results: Array<unknown>;
+};
+type PaginatedAdminUserListResponseWritable = {
+    status: string;
+    data: PaginatedAdminUserListWritable;
+};
+type PaginatedUserMukuruTransactionListWritable = {
+    count: number;
+    next?: string | null;
+    previous?: string | null;
+    results: Array<unknown>;
+};
+type PaginatedUserMukuruTransactionListResponseWritable = {
+    status: string;
+    data: PaginatedUserMukuruTransactionListWritable;
+};
+/**
+ * Per-company Mukuru payout product, configurable by company admins via
+ * `/api/admin/products/`. Lets clients self-configure their own catalog
+ * (production GUIDs differ per environment) instead of relying on the
+ * `seed_mukuru_products` sandbox management command.
+ *
+ * `company` is never client-supplied — it's taken from the authenticated
+ * admin's company in the view. Uniqueness of (company, payment_method) is
+ * enforced here (cleanly, as a 400) on top of the model's
+ * unique_together, so duplicate POSTs don't surface as a 500.
+ */
+type PatchedAdminMukuruProductWritable = {
+    payment_method?: string;
+    product_guid?: string;
+    country_code?: string;
+    payout_currency?: string;
+    settlement_currency?: string;
+    min_payout_amount?: string | null;
+    max_payout_amount?: string | null;
+    active?: boolean;
+};
+/**
+ * Write variant of `AdminCompanySerializer` used for PATCH/PUT. Secrets
+ * are writable here (plain CharFields) but marked write-only so the
+ * PATCH response can't leak the plaintext the admin just sent — the
+ * dashboard refetches via GET to display the masked values.
+ */
+type PatchedAdminUpdateCompanyWritable = {
+    mukuru_keycloak_client_id?: string;
+    mukuru_keycloak_client_secret?: string;
+    mukuru_keycloak_token_url?: string;
+    mukuru_base_url?: string;
+    mukuru_operational_address?: string;
+    /**
+     * * `base` - Base
+     */
+    mukuru_chain?: 'base';
+    mukuru_callback_password?: string;
+    business_sender_first_name?: string;
+    business_sender_last_name?: string;
+    business_sender_street_address?: string;
+    business_sender_city?: string;
+    business_sender_region?: string;
+    business_sender_postal_code?: string;
+    business_sender_country_code?: string;
+};
+type UserMukuruTransactionResponseWritable = {
+    status: string;
+};
+type ActivateCreateData = {
+    body: Activate;
+    path?: never;
+    query?: never;
+    url: '/activate/';
+};
+type ActivateCreateResponses = {
+    200: ActionResponse;
+};
+type ActivateCreateResponse = ActivateCreateResponses[keyof ActivateCreateResponses];
+type AdminCompanyRetrieveData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/admin/company/';
+};
+type AdminCompanyRetrieveResponses = {
+    200: AdminCompanyResponse;
+};
+type AdminCompanyRetrieveResponse = AdminCompanyRetrieveResponses[keyof AdminCompanyRetrieveResponses];
+type AdminCompanyPartialUpdateData = {
+    body?: PatchedAdminUpdateCompanyWritable;
+    path?: never;
+    query?: never;
+    url: '/admin/company/';
+};
+type AdminCompanyPartialUpdateResponses = {
+    200: AdminCompanyResponse;
+};
+type AdminCompanyPartialUpdateResponse = AdminCompanyPartialUpdateResponses[keyof AdminCompanyPartialUpdateResponses];
+type AdminCompanyUpdateData = {
+    body?: AdminUpdateCompanyWritable;
+    path?: never;
+    query?: never;
+    url: '/admin/company/';
+};
+type AdminCompanyUpdateResponses = {
+    200: AdminCompanyResponse;
+};
+type AdminCompanyUpdateResponse = AdminCompanyUpdateResponses[keyof AdminCompanyUpdateResponses];
+type AdminOperationalAccountsRetrieveData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/admin/operational-accounts/';
+};
+type AdminOperationalAccountsRetrieveResponses = {
+    200: AdminOperationalAccounts;
+};
+type AdminOperationalAccountsRetrieveResponse = AdminOperationalAccountsRetrieveResponses[keyof AdminOperationalAccountsRetrieveResponses];
+type AdminProductsListData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * A page number within the paginated result set.
+         */
+        page?: number;
+        /**
+         * Number of results to return per page.
+         */
+        page_size?: number;
+    };
+    url: '/admin/products/';
+};
+type AdminProductsListResponses = {
+    200: PaginatedAdminMukuruProductListResponse;
+};
+type AdminProductsListResponse = AdminProductsListResponses[keyof AdminProductsListResponses];
+type AdminProductsCreateData = {
+    body: AdminMukuruProductWritable;
+    path?: never;
+    query?: never;
+    url: '/admin/products/';
+};
+type AdminProductsCreateResponses = {
+    201: AdminMukuruProductResponse;
+};
+type AdminProductsCreateResponse = AdminProductsCreateResponses[keyof AdminProductsCreateResponses];
+type AdminProductsDestroyData = {
+    body?: never;
+    path: {
+        payment_method: string;
+    };
+    query?: never;
+    url: '/admin/products/{payment_method}/';
+};
+type AdminProductsDestroyResponses = {
+    200: AdminMukuruProductResponse;
+};
+type AdminProductsDestroyResponse = AdminProductsDestroyResponses[keyof AdminProductsDestroyResponses];
+type AdminProductsRetrieveData = {
+    body?: never;
+    path: {
+        payment_method: string;
+    };
+    query?: never;
+    url: '/admin/products/{payment_method}/';
+};
+type AdminProductsRetrieveResponses = {
+    200: AdminMukuruProductResponse;
+};
+type AdminProductsRetrieveResponse = AdminProductsRetrieveResponses[keyof AdminProductsRetrieveResponses];
+type AdminProductsPartialUpdateData = {
+    body?: PatchedAdminMukuruProductWritable;
+    path: {
+        payment_method: string;
+    };
+    query?: never;
+    url: '/admin/products/{payment_method}/';
+};
+type AdminProductsPartialUpdateResponses = {
+    200: AdminMukuruProductResponse;
+};
+type AdminProductsPartialUpdateResponse = AdminProductsPartialUpdateResponses[keyof AdminProductsPartialUpdateResponses];
+type AdminProductsUpdateData = {
+    body: AdminMukuruProductWritable;
+    path: {
+        payment_method: string;
+    };
+    query?: never;
+    url: '/admin/products/{payment_method}/';
+};
+type AdminProductsUpdateResponses = {
+    200: AdminMukuruProductResponse;
+};
+type AdminProductsUpdateResponse = AdminProductsUpdateResponses[keyof AdminProductsUpdateResponses];
+type AdminTransactionsListData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * A page number within the paginated result set.
+         */
+        page?: number;
+        /**
+         * Number of results to return per page.
+         */
+        page_size?: number;
+    };
+    url: '/admin/transactions/';
+};
+type AdminTransactionsListResponses = {
+    200: PaginatedAdminMukuruTransactionListResponse;
+};
+type AdminTransactionsListResponse = AdminTransactionsListResponses[keyof AdminTransactionsListResponses];
+type AdminTransactionsRetrieveData = {
+    body?: never;
+    path: {
+        rehive_transaction_id: string;
+    };
+    query?: never;
+    url: '/admin/transactions/{rehive_transaction_id}/';
+};
+type AdminTransactionsRetrieveResponses = {
+    200: AdminMukuruTransactionResponse;
+};
+type AdminTransactionsRetrieveResponse = AdminTransactionsRetrieveResponses[keyof AdminTransactionsRetrieveResponses];
+type AdminTransactionsCancelCreateData = {
+    body?: never;
+    path: {
+        rehive_transaction_id: string;
+    };
+    query?: never;
+    url: '/admin/transactions/{rehive_transaction_id}/cancel/';
+};
+type AdminTransactionsCancelCreateResponses = {
+    /**
+     * No response body
+     */
+    200: unknown;
+};
+type AdminTransactionsRefreshStatusCreateData = {
+    body?: never;
+    path: {
+        rehive_transaction_id: string;
+    };
+    query?: never;
+    url: '/admin/transactions/{rehive_transaction_id}/refresh-status/';
+};
+type AdminTransactionsRefreshStatusCreateResponses = {
+    /**
+     * No response body
+     */
+    200: unknown;
+};
+type AdminUsersListData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * A page number within the paginated result set.
+         */
+        page?: number;
+        /**
+         * Number of results to return per page.
+         */
+        page_size?: number;
+    };
+    url: '/admin/users/';
+};
+type AdminUsersListResponses = {
+    200: PaginatedAdminUserListResponse;
+};
+type AdminUsersListResponse = AdminUsersListResponses[keyof AdminUsersListResponses];
+type DeactivateCreateData = {
+    body: Deactivate;
+    path?: never;
+    query?: never;
+    url: '/deactivate/';
+};
+type DeactivateCreateResponses = {
+    200: ActionResponse;
+};
+type DeactivateCreateResponse = DeactivateCreateResponses[keyof DeactivateCreateResponses];
+type MukuruCallbackCreateData = {
+    body?: never;
+    path: {
+        company_identifier: string;
+    };
+    query?: never;
+    url: '/mukuru/callback/{company_identifier}/';
+};
+type MukuruCallbackCreateResponses = {
+    /**
+     * No response body
+     */
+    200: unknown;
+};
+type UserCatalogsRetrieveData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/user/catalogs/';
+};
+type UserCatalogsRetrieveResponses = {
+    /**
+     * No response body
+     */
+    200: unknown;
+};
+type UserQuoteCreateData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/user/quote/';
+};
+type UserQuoteCreateResponses = {
+    /**
+     * No response body
+     */
+    200: unknown;
+};
+type UserTransactionsListData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * A page number within the paginated result set.
+         */
+        page?: number;
+        /**
+         * Number of results to return per page.
+         */
+        page_size?: number;
+    };
+    url: '/user/transactions/';
+};
+type UserTransactionsListResponses = {
+    200: PaginatedUserMukuruTransactionListResponse;
+};
+type UserTransactionsListResponse = UserTransactionsListResponses[keyof UserTransactionsListResponses];
+type UserTransactionsRetrieveData = {
+    body?: never;
+    path: {
+        rehive_transaction_id: string;
+    };
+    query?: never;
+    url: '/user/transactions/{rehive_transaction_id}/';
+};
+type UserTransactionsRetrieveResponses = {
+    200: UserMukuruTransactionResponse;
+};
+type UserTransactionsRetrieveResponse = UserTransactionsRetrieveResponses[keyof UserTransactionsRetrieveResponses];
+type UserTransactionsCancelCreateData = {
+    body?: never;
+    path: {
+        rehive_transaction_id: string;
+    };
+    query?: never;
+    url: '/user/transactions/{rehive_transaction_id}/cancel/';
+};
+type UserTransactionsCancelCreateResponses = {
+    /**
+     * No response body
+     */
+    200: unknown;
+};
+type WebhookCreateData = {
+    body: Webhook;
+    path?: never;
+    query?: never;
+    url: '/webhook/';
+};
+type WebhookCreateResponses = {
+    200: ActionResponse;
+};
+type WebhookCreateResponse = WebhookCreateResponses[keyof WebhookCreateResponses];
+
+type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options$1<TData, ThrowOnError, TResponse> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: keyof ClientMeta extends never ? Record<string, unknown> : ClientMeta;
+};
+declare const activateCreate: <ThrowOnError extends boolean = false>(options: Options<ActivateCreateData, ThrowOnError>) => RequestResult<ActivateCreateResponses, unknown, ThrowOnError>;
+declare const adminCompanyRetrieve: <ThrowOnError extends boolean = false>(options?: Options<AdminCompanyRetrieveData, ThrowOnError>) => RequestResult<AdminCompanyRetrieveResponses, unknown, ThrowOnError>;
+declare const adminCompanyPartialUpdate: <ThrowOnError extends boolean = false>(options?: Options<AdminCompanyPartialUpdateData, ThrowOnError>) => RequestResult<AdminCompanyPartialUpdateResponses, unknown, ThrowOnError>;
+declare const adminCompanyUpdate: <ThrowOnError extends boolean = false>(options?: Options<AdminCompanyUpdateData, ThrowOnError>) => RequestResult<AdminCompanyUpdateResponses, unknown, ThrowOnError>;
+declare const adminOperationalAccountsRetrieve: <ThrowOnError extends boolean = false>(options?: Options<AdminOperationalAccountsRetrieveData, ThrowOnError>) => RequestResult<AdminOperationalAccountsRetrieveResponses, unknown, ThrowOnError>;
+declare const adminProductsList: <ThrowOnError extends boolean = false>(options?: Options<AdminProductsListData, ThrowOnError>) => RequestResult<AdminProductsListResponses, unknown, ThrowOnError>;
+declare const adminProductsCreate: <ThrowOnError extends boolean = false>(options: Options<AdminProductsCreateData, ThrowOnError>) => RequestResult<AdminProductsCreateResponses, unknown, ThrowOnError>;
+declare const adminProductsDestroy: <ThrowOnError extends boolean = false>(options: Options<AdminProductsDestroyData, ThrowOnError>) => RequestResult<AdminProductsDestroyResponses, unknown, ThrowOnError>;
+declare const adminProductsRetrieve: <ThrowOnError extends boolean = false>(options: Options<AdminProductsRetrieveData, ThrowOnError>) => RequestResult<AdminProductsRetrieveResponses, unknown, ThrowOnError>;
+declare const adminProductsPartialUpdate: <ThrowOnError extends boolean = false>(options: Options<AdminProductsPartialUpdateData, ThrowOnError>) => RequestResult<AdminProductsPartialUpdateResponses, unknown, ThrowOnError>;
+declare const adminProductsUpdate: <ThrowOnError extends boolean = false>(options: Options<AdminProductsUpdateData, ThrowOnError>) => RequestResult<AdminProductsUpdateResponses, unknown, ThrowOnError>;
+declare const adminTransactionsList: <ThrowOnError extends boolean = false>(options?: Options<AdminTransactionsListData, ThrowOnError>) => RequestResult<AdminTransactionsListResponses, unknown, ThrowOnError>;
+declare const adminTransactionsRetrieve: <ThrowOnError extends boolean = false>(options: Options<AdminTransactionsRetrieveData, ThrowOnError>) => RequestResult<AdminTransactionsRetrieveResponses, unknown, ThrowOnError>;
+declare const adminTransactionsCancelCreate: <ThrowOnError extends boolean = false>(options: Options<AdminTransactionsCancelCreateData, ThrowOnError>) => RequestResult<AdminTransactionsCancelCreateResponses, unknown, ThrowOnError>;
+declare const adminTransactionsRefreshStatusCreate: <ThrowOnError extends boolean = false>(options: Options<AdminTransactionsRefreshStatusCreateData, ThrowOnError>) => RequestResult<AdminTransactionsRefreshStatusCreateResponses, unknown, ThrowOnError>;
+declare const adminUsersList: <ThrowOnError extends boolean = false>(options?: Options<AdminUsersListData, ThrowOnError>) => RequestResult<AdminUsersListResponses, unknown, ThrowOnError>;
+declare const deactivateCreate: <ThrowOnError extends boolean = false>(options: Options<DeactivateCreateData, ThrowOnError>) => RequestResult<DeactivateCreateResponses, unknown, ThrowOnError>;
+declare const mukuruCallbackCreate: <ThrowOnError extends boolean = false>(options: Options<MukuruCallbackCreateData, ThrowOnError>) => RequestResult<MukuruCallbackCreateResponses, unknown, ThrowOnError>;
+declare const userCatalogsRetrieve: <ThrowOnError extends boolean = false>(options?: Options<UserCatalogsRetrieveData, ThrowOnError>) => RequestResult<UserCatalogsRetrieveResponses, unknown, ThrowOnError>;
+declare const userQuoteCreate: <ThrowOnError extends boolean = false>(options?: Options<UserQuoteCreateData, ThrowOnError>) => RequestResult<UserQuoteCreateResponses, unknown, ThrowOnError>;
+declare const userTransactionsList: <ThrowOnError extends boolean = false>(options?: Options<UserTransactionsListData, ThrowOnError>) => RequestResult<UserTransactionsListResponses, unknown, ThrowOnError>;
+declare const userTransactionsRetrieve: <ThrowOnError extends boolean = false>(options: Options<UserTransactionsRetrieveData, ThrowOnError>) => RequestResult<UserTransactionsRetrieveResponses, unknown, ThrowOnError>;
+declare const userTransactionsCancelCreate: <ThrowOnError extends boolean = false>(options: Options<UserTransactionsCancelCreateData, ThrowOnError>) => RequestResult<UserTransactionsCancelCreateResponses, unknown, ThrowOnError>;
+declare const webhookCreate: <ThrowOnError extends boolean = false>(options: Options<WebhookCreateData, ThrowOnError>) => RequestResult<WebhookCreateResponses, unknown, ThrowOnError>;
+
+type sdk_Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options<TData, ThrowOnError, TResponse>;
+declare const sdk_activateCreate: typeof activateCreate;
+declare const sdk_adminCompanyPartialUpdate: typeof adminCompanyPartialUpdate;
+declare const sdk_adminCompanyRetrieve: typeof adminCompanyRetrieve;
+declare const sdk_adminCompanyUpdate: typeof adminCompanyUpdate;
+declare const sdk_adminOperationalAccountsRetrieve: typeof adminOperationalAccountsRetrieve;
+declare const sdk_adminProductsCreate: typeof adminProductsCreate;
+declare const sdk_adminProductsDestroy: typeof adminProductsDestroy;
+declare const sdk_adminProductsList: typeof adminProductsList;
+declare const sdk_adminProductsPartialUpdate: typeof adminProductsPartialUpdate;
+declare const sdk_adminProductsRetrieve: typeof adminProductsRetrieve;
+declare const sdk_adminProductsUpdate: typeof adminProductsUpdate;
+declare const sdk_adminTransactionsCancelCreate: typeof adminTransactionsCancelCreate;
+declare const sdk_adminTransactionsList: typeof adminTransactionsList;
+declare const sdk_adminTransactionsRefreshStatusCreate: typeof adminTransactionsRefreshStatusCreate;
+declare const sdk_adminTransactionsRetrieve: typeof adminTransactionsRetrieve;
+declare const sdk_adminUsersList: typeof adminUsersList;
+declare const sdk_deactivateCreate: typeof deactivateCreate;
+declare const sdk_mukuruCallbackCreate: typeof mukuruCallbackCreate;
+declare const sdk_userCatalogsRetrieve: typeof userCatalogsRetrieve;
+declare const sdk_userQuoteCreate: typeof userQuoteCreate;
+declare const sdk_userTransactionsCancelCreate: typeof userTransactionsCancelCreate;
+declare const sdk_userTransactionsList: typeof userTransactionsList;
+declare const sdk_userTransactionsRetrieve: typeof userTransactionsRetrieve;
+declare const sdk_webhookCreate: typeof webhookCreate;
+declare namespace sdk {
+  export { type sdk_Options as Options, sdk_activateCreate as activateCreate, sdk_adminCompanyPartialUpdate as adminCompanyPartialUpdate, sdk_adminCompanyRetrieve as adminCompanyRetrieve, sdk_adminCompanyUpdate as adminCompanyUpdate, sdk_adminOperationalAccountsRetrieve as adminOperationalAccountsRetrieve, sdk_adminProductsCreate as adminProductsCreate, sdk_adminProductsDestroy as adminProductsDestroy, sdk_adminProductsList as adminProductsList, sdk_adminProductsPartialUpdate as adminProductsPartialUpdate, sdk_adminProductsRetrieve as adminProductsRetrieve, sdk_adminProductsUpdate as adminProductsUpdate, sdk_adminTransactionsCancelCreate as adminTransactionsCancelCreate, sdk_adminTransactionsList as adminTransactionsList, sdk_adminTransactionsRefreshStatusCreate as adminTransactionsRefreshStatusCreate, sdk_adminTransactionsRetrieve as adminTransactionsRetrieve, sdk_adminUsersList as adminUsersList, sdk_deactivateCreate as deactivateCreate, sdk_mukuruCallbackCreate as mukuruCallbackCreate, sdk_userCatalogsRetrieve as userCatalogsRetrieve, sdk_userQuoteCreate as userQuoteCreate, sdk_userTransactionsCancelCreate as userTransactionsCancelCreate, sdk_userTransactionsList as userTransactionsList, sdk_userTransactionsRetrieve as userTransactionsRetrieve, sdk_webhookCreate as webhookCreate };
+}
+
+type MukuruApi = BoundSdk<typeof sdk>;
+declare function createMukuruApi(config: ApiFactoryConfig): MukuruApi;
+
+export { type ActionResponse, type Activate, type ActivateCreateData, type ActivateCreateResponse, type ActivateCreateResponses, type AdminCompany, type AdminCompanyPartialUpdateData, type AdminCompanyPartialUpdateResponse, type AdminCompanyPartialUpdateResponses, type AdminCompanyResponse, type AdminCompanyResponseWritable, type AdminCompanyRetrieveData, type AdminCompanyRetrieveResponse, type AdminCompanyRetrieveResponses, type AdminCompanyUpdateData, type AdminCompanyUpdateResponse, type AdminCompanyUpdateResponses, type AdminCompanyWritable, type AdminMukuruProduct, type AdminMukuruProductResponse, type AdminMukuruProductResponseWritable, type AdminMukuruProductWritable, type AdminMukuruTransaction, type AdminMukuruTransactionResponse, type AdminMukuruTransactionResponseWritable, type AdminOperationalAccount, type AdminOperationalAccounts, type AdminOperationalAccountsRetrieveData, type AdminOperationalAccountsRetrieveResponse, type AdminOperationalAccountsRetrieveResponses, type AdminProductsCreateData, type AdminProductsCreateResponse, type AdminProductsCreateResponses, type AdminProductsDestroyData, type AdminProductsDestroyResponse, type AdminProductsDestroyResponses, type AdminProductsListData, type AdminProductsListResponse, type AdminProductsListResponses, type AdminProductsPartialUpdateData, type AdminProductsPartialUpdateResponse, type AdminProductsPartialUpdateResponses, type AdminProductsRetrieveData, type AdminProductsRetrieveResponse, type AdminProductsRetrieveResponses, type AdminProductsUpdateData, type AdminProductsUpdateResponse, type AdminProductsUpdateResponses, type AdminTransactionsCancelCreateData, type AdminTransactionsCancelCreateResponses, type AdminTransactionsListData, type AdminTransactionsListResponse, type AdminTransactionsListResponses, type AdminTransactionsRefreshStatusCreateData, type AdminTransactionsRefreshStatusCreateResponses, type AdminTransactionsRetrieveData, type AdminTransactionsRetrieveResponse, type AdminTransactionsRetrieveResponses, type AdminUpdateCompany, type AdminUpdateCompanyWritable, type AdminUser, type AdminUsersListData, type AdminUsersListResponse, type AdminUsersListResponses, type ClientOptions, type Deactivate, type DeactivateCreateData, type DeactivateCreateResponse, type DeactivateCreateResponses, type MukuruApi, type MukuruCallbackCreateData, type MukuruCallbackCreateResponses, type PaginatedAdminMukuruProductList, type PaginatedAdminMukuruProductListResponse, type PaginatedAdminMukuruProductListResponseWritable, type PaginatedAdminMukuruProductListWritable, type PaginatedAdminMukuruTransactionList, type PaginatedAdminMukuruTransactionListResponse, type PaginatedAdminMukuruTransactionListResponseWritable, type PaginatedAdminMukuruTransactionListWritable, type PaginatedAdminUserList, type PaginatedAdminUserListResponse, type PaginatedAdminUserListResponseWritable, type PaginatedAdminUserListWritable, type PaginatedUserMukuruTransactionList, type PaginatedUserMukuruTransactionListResponse, type PaginatedUserMukuruTransactionListResponseWritable, type PaginatedUserMukuruTransactionListWritable, type PatchedAdminMukuruProduct, type PatchedAdminMukuruProductWritable, type PatchedAdminUpdateCompany, type PatchedAdminUpdateCompanyWritable, type UserCatalogsRetrieveData, type UserCatalogsRetrieveResponses, type UserMukuruTransaction, type UserMukuruTransactionResponse, type UserMukuruTransactionResponseWritable, type UserQuoteCreateData, type UserQuoteCreateResponses, type UserTransactionsCancelCreateData, type UserTransactionsCancelCreateResponses, type UserTransactionsListData, type UserTransactionsListResponse, type UserTransactionsListResponses, type UserTransactionsRetrieveData, type UserTransactionsRetrieveResponse, type UserTransactionsRetrieveResponses, type Webhook, type WebhookCreateData, type WebhookCreateResponse, type WebhookCreateResponses, createMukuruApi };