@widgetic/api-sdk 1.0.24 → 1.0.26

package/dist/esm/apis/AdminApi.js

@@ -21,11 +21,104 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import * as runtime from '../runtime.js';
-import { AdminHealthStatusFromJSON, CleanupOrphanedInvitations200ResponseFromJSON, CleanupOrphanedInvitationsRequestToJSON, } from '../models/index.js';
+import { AdjustPartnerCredits200ResponseFromJSON, AdjustPartnerCreditsRequestToJSON, AdjustUserCredits200ResponseFromJSON, AdjustUserCreditsRequestToJSON, AdminHealthStatusFromJSON, CleanupOrphanedInvitations200ResponseFromJSON, CleanupOrphanedInvitationsRequestToJSON, CreatePartnerRequestToJSON, PartnerActivationFromJSON, PartnerBillingReportFromJSON, PartnerDetailsFromJSON, PartnerListFromJSON, PartnerUpdateResultFromJSON, PartnerWithWarningsFromJSON, RefundPartnerCreditsRequestToJSON, UpdatePartnerRequestToJSON, UpdatePartnerStatusRequestToJSON, } from '../models/index.js';
 /**
  *
  */
 export class AdminApi extends runtime.BaseAPI {
+    /**
+     * Admin only. A positive `amount` adds credits to the partner wallet; a negative `amount` removes them (the wallet must hold them). An `amount` of 0, or one that is not a finite number, is refused with 400. **One top-up may not exceed $100,000** (`BILLING_CONFIG.PARTNER_WALLET`), which is 1,000,000 credits at the list price of $0.10 per credit. A larger amount is refused with 400 and nothing is credited. The same ceiling applies to `POST /admin/billing/refund` and to the `creditBalance` field of `PUT /admin/partners/{partnerId}`. Removing credits is not limited by it. The `Idempotency-Key` header is required and names the adjustment: a retry with the same key replays the first result (`replayed: true`) instead of moving the balance twice, and a request without one is refused with 400. This moves a PARTNER\'s wallet. A user\'s balance is moved by `POST /admin/billing/credits/adjust`.
+     * Add credits to, or remove credits from, a partner\'s wallet
+     */
+    adjustPartnerCreditsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['partnerId'] == null) {
+                throw new runtime.RequiredError('partnerId', 'Required parameter "partnerId" was null or undefined when calling adjustPartnerCredits().');
+            }
+            if (requestParameters['idempotencyKey'] == null) {
+                throw new runtime.RequiredError('idempotencyKey', 'Required parameter "idempotencyKey" was null or undefined when calling adjustPartnerCredits().');
+            }
+            if (requestParameters['adjustPartnerCreditsRequest'] == null) {
+                throw new runtime.RequiredError('adjustPartnerCreditsRequest', 'Required parameter "adjustPartnerCreditsRequest" was null or undefined when calling adjustPartnerCredits().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (requestParameters['idempotencyKey'] != null) {
+                headerParameters['Idempotency-Key'] = String(requestParameters['idempotencyKey']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/admin/partners/{partnerId}/credits`.replace(`{${"partnerId"}}`, encodeURIComponent(String(requestParameters['partnerId']))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: AdjustPartnerCreditsRequestToJSON(requestParameters['adjustPartnerCreditsRequest']),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => AdjustPartnerCredits200ResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Admin only. A positive `amount` adds credits to the partner wallet; a negative `amount` removes them (the wallet must hold them). An `amount` of 0, or one that is not a finite number, is refused with 400. **One top-up may not exceed $100,000** (`BILLING_CONFIG.PARTNER_WALLET`), which is 1,000,000 credits at the list price of $0.10 per credit. A larger amount is refused with 400 and nothing is credited. The same ceiling applies to `POST /admin/billing/refund` and to the `creditBalance` field of `PUT /admin/partners/{partnerId}`. Removing credits is not limited by it. The `Idempotency-Key` header is required and names the adjustment: a retry with the same key replays the first result (`replayed: true`) instead of moving the balance twice, and a request without one is refused with 400. This moves a PARTNER\'s wallet. A user\'s balance is moved by `POST /admin/billing/credits/adjust`.
+     * Add credits to, or remove credits from, a partner\'s wallet
+     */
+    adjustPartnerCredits(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.adjustPartnerCreditsRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Admin only. A positive `amount` grants free credits; a negative `amount` takes credits away (the balance must hold them). An `amount` of 0, or one that is not a finite number, is refused with 400. The `Idempotency-Key` header is required and names the adjustment: a retry with the same key replays the first result (`replayed: true`) instead of moving the balance twice, and a request without one is refused with 400. Free credits are limited per admin: one request may grant at most `ADMIN_GRANT_MAX_PER_REQUEST` credits (default 5000) and one admin may grant at most `ADMIN_GRANT_DAILY_LIMIT` credits alone per UTC day (default 10000), counted across this route, `POST /credits/add` and the grants route (`POST /admin-billing/grants`). Removing credits is not counted. A request over the per-request limit is refused with 400; one that would pass the daily limit is refused with 429 and `ADMIN_GRANT_LIMIT_REACHED` (`error.details` has the limit, what was used, what is left and when the day resets). This moves a USER\'s balance. A partner\'s wallet is moved by `POST /admin/partners/{partnerId}/credits`.
+     * Add credits to, or remove credits from, a user\'s balance
+     */
+    adjustUserCreditsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['idempotencyKey'] == null) {
+                throw new runtime.RequiredError('idempotencyKey', 'Required parameter "idempotencyKey" was null or undefined when calling adjustUserCredits().');
+            }
+            if (requestParameters['adjustUserCreditsRequest'] == null) {
+                throw new runtime.RequiredError('adjustUserCreditsRequest', 'Required parameter "adjustUserCreditsRequest" was null or undefined when calling adjustUserCredits().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (requestParameters['idempotencyKey'] != null) {
+                headerParameters['Idempotency-Key'] = String(requestParameters['idempotencyKey']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/admin/billing/credits/adjust`,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: AdjustUserCreditsRequestToJSON(requestParameters['adjustUserCreditsRequest']),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => AdjustUserCredits200ResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Admin only. A positive `amount` grants free credits; a negative `amount` takes credits away (the balance must hold them). An `amount` of 0, or one that is not a finite number, is refused with 400. The `Idempotency-Key` header is required and names the adjustment: a retry with the same key replays the first result (`replayed: true`) instead of moving the balance twice, and a request without one is refused with 400. Free credits are limited per admin: one request may grant at most `ADMIN_GRANT_MAX_PER_REQUEST` credits (default 5000) and one admin may grant at most `ADMIN_GRANT_DAILY_LIMIT` credits alone per UTC day (default 10000), counted across this route, `POST /credits/add` and the grants route (`POST /admin-billing/grants`). Removing credits is not counted. A request over the per-request limit is refused with 400; one that would pass the daily limit is refused with 429 and `ADMIN_GRANT_LIMIT_REACHED` (`error.details` has the limit, what was used, what is left and when the day resets). This moves a USER\'s balance. A partner\'s wallet is moved by `POST /admin/partners/{partnerId}/credits`.
+     * Add credits to, or remove credits from, a user\'s balance
+     */
+    adjustUserCredits(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.adjustUserCreditsRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Detailed health check for admin users, including database health records.
      * Admin Health Check
@@ -105,4 +198,454 @@ export class AdminApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Admin only. This is how a partner comes to exist; there is no self-serve sign-up for one. **Before calling it**, the user who will administer the partner must exist and have the `partner` role (`PUT /admin/users/{userId}/role`). Every partner route belongs to that role, so a partner administered by an ordinary user would be created and then be unusable; such a request is refused with 400 and says so. A user with the `admin` role is accepted too. **A partner has no API key of its own, and none is issued.** The administrator calls the API with the `wgt_prt_` key of their own account: they make it themselves (`POST /users/{id}/keys`, or the dashboard\'s key screen), or Widgetic staff make it for them (the same route, called by an admin). **The new partner starts inactive, and is unusable until an administrator activates it.** A partner has no trial and pays from day one, so nothing it or its customers do works yet: its embeds are not served, its editor sessions are refused and its API key can only read and manage its billing. Activate it with `PUT /admin/partners/{partnerId}/status` (`active`) once the contract and a verified storage destination are in place (`GET /admin/partners/{partnerId}/activation` lists what is missing). Sending `isActive: true` here is refused, because it would skip that check. The new partner starts with an empty wallet and no contract. Fund the wallet with `POST /admin/partners/{partnerId}/credits` and record the contract terms with `POST /partner-customizations/{partnerId}`. Neither is a field of this request, and a field this request does not name is refused with 400 rather than ignored. Creating the partner also records the partner plan on its administrator\'s own account (`plan.partner`). A partner is not bought, so the administrator\'s account holds no subscription of its own. If that record could not be written the partner is still created (a refusal would hide that it exists, and a retry would be a 409) and `warnings` says so; sending the status `active` for the partner again (`PUT /admin/partners/{partnerId}/status`) records it. Pausing or deactivating the partner stops what it published from being served. A partner `name` is unique: one already in use is refused with 409 and nothing is created. This route takes no `Idempotency-Key`: the unique name makes a retry safe on its own. A retry after a dropped response gets 409 for the partner the first attempt created; find it with `GET /admin/partners` (`searchTerm`).
+     * Create a partner
+     */
+    createPartnerRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['createPartnerRequest'] == null) {
+                throw new runtime.RequiredError('createPartnerRequest', 'Required parameter "createPartnerRequest" was null or undefined when calling createPartner().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/admin/partners`,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: CreatePartnerRequestToJSON(requestParameters['createPartnerRequest']),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => PartnerWithWarningsFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Admin only. This is how a partner comes to exist; there is no self-serve sign-up for one. **Before calling it**, the user who will administer the partner must exist and have the `partner` role (`PUT /admin/users/{userId}/role`). Every partner route belongs to that role, so a partner administered by an ordinary user would be created and then be unusable; such a request is refused with 400 and says so. A user with the `admin` role is accepted too. **A partner has no API key of its own, and none is issued.** The administrator calls the API with the `wgt_prt_` key of their own account: they make it themselves (`POST /users/{id}/keys`, or the dashboard\'s key screen), or Widgetic staff make it for them (the same route, called by an admin). **The new partner starts inactive, and is unusable until an administrator activates it.** A partner has no trial and pays from day one, so nothing it or its customers do works yet: its embeds are not served, its editor sessions are refused and its API key can only read and manage its billing. Activate it with `PUT /admin/partners/{partnerId}/status` (`active`) once the contract and a verified storage destination are in place (`GET /admin/partners/{partnerId}/activation` lists what is missing). Sending `isActive: true` here is refused, because it would skip that check. The new partner starts with an empty wallet and no contract. Fund the wallet with `POST /admin/partners/{partnerId}/credits` and record the contract terms with `POST /partner-customizations/{partnerId}`. Neither is a field of this request, and a field this request does not name is refused with 400 rather than ignored. Creating the partner also records the partner plan on its administrator\'s own account (`plan.partner`). A partner is not bought, so the administrator\'s account holds no subscription of its own. If that record could not be written the partner is still created (a refusal would hide that it exists, and a retry would be a 409) and `warnings` says so; sending the status `active` for the partner again (`PUT /admin/partners/{partnerId}/status`) records it. Pausing or deactivating the partner stops what it published from being served. A partner `name` is unique: one already in use is refused with 409 and nothing is created. This route takes no `Idempotency-Key`: the unique name makes a retry safe on its own. A retry after a dropped response gets 409 for the partner the first attempt created; find it with `GET /admin/partners` (`searchTerm`).
+     * Create a partner
+     */
+    createPartner(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.createPartnerRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * The retained-window rollup for every JEV decision point: decision counts, `trustedRate` (jev vs legacy), the fallback reasons behind `degradedRate`, token before/after and the measured savings, routing and outcome counts (including the build-error auto-fix trio), the per-prompt recurrence ranking, and each decision point\'s effective rollout mode. The build-error anchor telemetry additionally breaks its `anchor_*` outcomes down by the anchor source that carried (`anchorsBySource`), so the malformed-SEARCH rate is watchable per excerpt resolution without log diving. The recurrence ranking is served at both horizons: `prompts` covers the in-process window, `promptsPersisted` the 28-day rolling counts kept in the shared store (null there means the store could not be asked — an outage is not a measured zero). The repair steering counts ride the same two horizons: `preferredToolsByRoute` is the per-class window cross-tab, `repairLeadsPersisted` the persisted error/finding/none tally over the same events, so the steer rate reads across restarts. Read-only, and computed from the same snapshot the logs are built from — no thresholds are applied here; the gates live in `__docs/10-jev/going-live.md`. Everything but `promptsPersisted` covers the current process, so restarts reset it.
+     * JEV decision rollup (admin)
+     */
+    getJevMetricsRaw(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/admin/jev/metrics`,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response);
+        });
+    }
+    /**
+     * The retained-window rollup for every JEV decision point: decision counts, `trustedRate` (jev vs legacy), the fallback reasons behind `degradedRate`, token before/after and the measured savings, routing and outcome counts (including the build-error auto-fix trio), the per-prompt recurrence ranking, and each decision point\'s effective rollout mode. The build-error anchor telemetry additionally breaks its `anchor_*` outcomes down by the anchor source that carried (`anchorsBySource`), so the malformed-SEARCH rate is watchable per excerpt resolution without log diving. The recurrence ranking is served at both horizons: `prompts` covers the in-process window, `promptsPersisted` the 28-day rolling counts kept in the shared store (null there means the store could not be asked — an outage is not a measured zero). The repair steering counts ride the same two horizons: `preferredToolsByRoute` is the per-class window cross-tab, `repairLeadsPersisted` the persisted error/finding/none tally over the same events, so the steer rate reads across restarts. Read-only, and computed from the same snapshot the logs are built from — no thresholds are applied here; the gates live in `__docs/10-jev/going-live.md`. Everything but `promptsPersisted` covers the current process, so restarts reset it.
+     * JEV decision rollup (admin)
+     */
+    getJevMetrics(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getJevMetricsRaw(initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Admin only. The checklist `PUT /admin/partners/{partnerId}/status` applies when a partner that was never activated is switched on: a contract in force today (`contract`) and a storage destination that was verified and still works (`storage`). Each entry says whether it is met and, when it is not, what to do. Nothing is changed by reading it, so the Partners screen can show it beside the Activate button. `required` is false for a partner that is active or paused: resuming a paused partner is never held up by the checklist. An unpaid invoice is not a requirement.
+     * What a partner needs before it can be activated
+     */
+    getPartnerActivationRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['partnerId'] == null) {
+                throw new runtime.RequiredError('partnerId', 'Required parameter "partnerId" was null or undefined when calling getPartnerActivation().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/admin/partners/{partnerId}/activation`.replace(`{${"partnerId"}}`, encodeURIComponent(String(requestParameters['partnerId']))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => PartnerActivationFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Admin only. The checklist `PUT /admin/partners/{partnerId}/status` applies when a partner that was never activated is switched on: a contract in force today (`contract`) and a storage destination that was verified and still works (`storage`). Each entry says whether it is met and, when it is not, what to do. Nothing is changed by reading it, so the Partners screen can show it beside the Activate button. `required` is false for a partner that is active or paused: resuming a paused partner is never held up by the checklist. An unpaid invoice is not a requirement.
+     * What a partner needs before it can be activated
+     */
+    getPartnerActivation(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getPartnerActivationRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Admin only. What the partner\'s wallet did over the period, from the ledger: the totals (credits consumed and credits issued, over every row of the period however many there are), the same totals per calendar month, and, when `includeTransactions` is true, the newest ledger rows themselves. The period is the last 30 days when `startDate` and `endDate` are not given. A date that is not a date, or a start after the end, is refused with 400. The list of rows is bounded (the newest 1,000 of the period, complete); `transactionsTruncated` says when the period holds more than the list shows. The totals are never cut.
+     * Get a partner\'s wallet activity for a period
+     */
+    getPartnerBillingReportRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['partnerId'] == null) {
+                throw new runtime.RequiredError('partnerId', 'Required parameter "partnerId" was null or undefined when calling getPartnerBillingReport().');
+            }
+            const queryParameters = {};
+            if (requestParameters['startDate'] != null) {
+                queryParameters['startDate'] = requestParameters['startDate'].toISOString();
+            }
+            if (requestParameters['endDate'] != null) {
+                queryParameters['endDate'] = requestParameters['endDate'].toISOString();
+            }
+            if (requestParameters['includeTransactions'] != null) {
+                queryParameters['includeTransactions'] = requestParameters['includeTransactions'];
+            }
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/admin/partners/{partnerId}/billing-report`.replace(`{${"partnerId"}}`, encodeURIComponent(String(requestParameters['partnerId']))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => PartnerBillingReportFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Admin only. What the partner\'s wallet did over the period, from the ledger: the totals (credits consumed and credits issued, over every row of the period however many there are), the same totals per calendar month, and, when `includeTransactions` is true, the newest ledger rows themselves. The period is the last 30 days when `startDate` and `endDate` are not given. A date that is not a date, or a start after the end, is refused with 400. The list of rows is bounded (the newest 1,000 of the period, complete); `transactionsTruncated` says when the period holds more than the list shows. The totals are never cut.
+     * Get a partner\'s wallet activity for a period
+     */
+    getPartnerBillingReport(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getPartnerBillingReportRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Admin only. The partner, with three things an administrator needs beside it: the billing overview (wallet, auto-reload settings, the ten newest ledger rows, the contract if one is recorded), the statistics of the last month\'s wallet activity, and a little metadata. The overview and the statistics are read at request time and are `null` when they could not be assembled: the partner itself is still returned. `monthlyStats.userCount` is `null` while the partner\'s member list cannot be read.
+     * Get a partner with its billing overview and last month\'s statistics
+     */
+    getPartnerDetailsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['partnerId'] == null) {
+                throw new runtime.RequiredError('partnerId', 'Required parameter "partnerId" was null or undefined when calling getPartnerDetails().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/admin/partners/{partnerId}`.replace(`{${"partnerId"}}`, encodeURIComponent(String(requestParameters['partnerId']))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => PartnerDetailsFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Admin only. The partner, with three things an administrator needs beside it: the billing overview (wallet, auto-reload settings, the ten newest ledger rows, the contract if one is recorded), the statistics of the last month\'s wallet activity, and a little metadata. The overview and the statistics are read at request time and are `null` when they could not be assembled: the partner itself is still returned. `monthlyStats.userCount` is `null` while the partner\'s member list cannot be read.
+     * Get a partner with its billing overview and last month\'s statistics
+     */
+    getPartnerDetails(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getPartnerDetailsRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Admin only. `scope=mine` is the signed-in admin\'s widgets. `scope=all` is every account. `preset=true` keeps widgets marked for signup copy. A normal account cannot call this route.
+     * List widgets for the admin console
+     */
+    listAdminWidgetsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryParameters = {};
+            if (requestParameters['scope'] != null) {
+                queryParameters['scope'] = requestParameters['scope'];
+            }
+            if (requestParameters['preset'] != null) {
+                queryParameters['preset'] = requestParameters['preset'];
+            }
+            if (requestParameters['search'] != null) {
+                queryParameters['search'] = requestParameters['search'];
+            }
+            if (requestParameters['page'] != null) {
+                queryParameters['page'] = requestParameters['page'];
+            }
+            if (requestParameters['size'] != null) {
+                queryParameters['size'] = requestParameters['size'];
+            }
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/admin/widgets`,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Admin only. `scope=mine` is the signed-in admin\'s widgets. `scope=all` is every account. `preset=true` keeps widgets marked for signup copy. A normal account cannot call this route.
+     * List widgets for the admin console
+     */
+    listAdminWidgets() {
+        return __awaiter(this, arguments, void 0, function* (requestParameters = {}, initOverrides) {
+            yield this.listAdminWidgetsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Admin only. One page of partners, newest first unless `sort` says otherwise. `status`, `searchTerm` and `sort` are applied before the page is cut, so `total` is the number of partners that match across all pages and every page is a page of matches. `searchTerm` matches the partner\'s name or billing email, whatever the case. It is plain text: characters such as `%`, `*` and `,` are searched for as themselves, not read as a pattern. `status` is the partner\'s standing: `active` (served), `inactive` (switched off), or `suspended` (switched off with a recorded reason; see `PUT /admin/partners/{partnerId}/status`).
+     * List partners
+     */
+    listPartnersRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryParameters = {};
+            if (requestParameters['page'] != null) {
+                queryParameters['page'] = requestParameters['page'];
+            }
+            if (requestParameters['size'] != null) {
+                queryParameters['size'] = requestParameters['size'];
+            }
+            if (requestParameters['status'] != null) {
+                queryParameters['status'] = requestParameters['status'];
+            }
+            if (requestParameters['searchTerm'] != null) {
+                queryParameters['searchTerm'] = requestParameters['searchTerm'];
+            }
+            if (requestParameters['sort'] != null) {
+                queryParameters['sort'] = requestParameters['sort'];
+            }
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/admin/partners`,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => PartnerListFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Admin only. One page of partners, newest first unless `sort` says otherwise. `status`, `searchTerm` and `sort` are applied before the page is cut, so `total` is the number of partners that match across all pages and every page is a page of matches. `searchTerm` matches the partner\'s name or billing email, whatever the case. It is plain text: characters such as `%`, `*` and `,` are searched for as themselves, not read as a pattern. `status` is the partner\'s standing: `active` (served), `inactive` (switched off), or `suspended` (switched off with a recorded reason; see `PUT /admin/partners/{partnerId}/status`).
+     * List partners
+     */
+    listPartners() {
+        return __awaiter(this, arguments, void 0, function* (requestParameters = {}, initOverrides) {
+            const response = yield this.listPartnersRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Admin only. Adds `amount` credits to the partner wallet as a refund. The `Idempotency-Key` header is required: a retry with the same key replays the first refund instead of issuing a second one. A refund is held to the same ceiling as a top-up: **at most $100,000 per operation** (1,000,000 credits at $0.10 per credit). A larger amount is refused with 400 and nothing is credited.
+     * Credit a partner\'s wallet back with a refund
+     */
+    refundPartnerCreditsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['idempotencyKey'] == null) {
+                throw new runtime.RequiredError('idempotencyKey', 'Required parameter "idempotencyKey" was null or undefined when calling refundPartnerCredits().');
+            }
+            if (requestParameters['refundPartnerCreditsRequest'] == null) {
+                throw new runtime.RequiredError('refundPartnerCreditsRequest', 'Required parameter "refundPartnerCreditsRequest" was null or undefined when calling refundPartnerCredits().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (requestParameters['idempotencyKey'] != null) {
+                headerParameters['Idempotency-Key'] = String(requestParameters['idempotencyKey']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/admin/billing/refund`,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: RefundPartnerCreditsRequestToJSON(requestParameters['refundPartnerCreditsRequest']),
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Admin only. Adds `amount` credits to the partner wallet as a refund. The `Idempotency-Key` header is required: a retry with the same key replays the first refund instead of issuing a second one. A refund is held to the same ceiling as a top-up: **at most $100,000 per operation** (1,000,000 credits at $0.10 per credit). A larger amount is refused with 400 and nothing is credited.
+     * Credit a partner\'s wallet back with a refund
+     */
+    refundPartnerCredits(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.refundPartnerCreditsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Admin only. Every field is optional; send the ones to change. The profile fields (`name`, `email`, `webhookUrl`, `allowedDomains`, `billingSettings`) are stored on the partner. `autoReloadAmount` and `autoReloadThreshold` are stored with the partner\'s auto-reload settings, which are a different record: an edit to one of them keeps the other and the rest of the configuration. `creditBalance` is a **target balance**, not a stored value. The wallet is moved by the difference between it and the balance the ledger holds now, as a ledger row, by the same keyed path `POST /admin/partners/{partnerId}/credits` uses. So a request that sets it **must** carry an `Idempotency-Key` (a request without one is refused with 400 and changes nothing, not even the fields beside it), a top-up is held to the same ceiling of $100,000 per operation, and a retry with the same key replays the first result instead of moving the wallet twice. `notes` becomes the reason on that ledger row. A request that sets no balance needs no key. `isActive` only flips the switch, and goes through the same check as `PUT /admin/partners/{partnerId}/status`: activating a partner that was never activated is refused with 409 `PARTNER_NOT_READY` until its contract and storage destination are in place, and the fields beside it are not written when it is refused. To pause a partner with a recorded reason, or to resume one so that everything the pause turned off is restored, use `PUT /admin/partners/{partnerId}/status`. The response is the partner as it is after the edit; `creditAdjustment` and `autoReload` report what was done to the wallet and the settings, when the request touched them.
+     * Edit a partner\'s profile, wallet balance or auto-reload settings
+     */
+    updatePartnerRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['partnerId'] == null) {
+                throw new runtime.RequiredError('partnerId', 'Required parameter "partnerId" was null or undefined when calling updatePartner().');
+            }
+            if (requestParameters['updatePartnerRequest'] == null) {
+                throw new runtime.RequiredError('updatePartnerRequest', 'Required parameter "updatePartnerRequest" was null or undefined when calling updatePartner().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (requestParameters['idempotencyKey'] != null) {
+                headerParameters['Idempotency-Key'] = String(requestParameters['idempotencyKey']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/admin/partners/{partnerId}`.replace(`{${"partnerId"}}`, encodeURIComponent(String(requestParameters['partnerId']))),
+                method: 'PUT',
+                headers: headerParameters,
+                query: queryParameters,
+                body: UpdatePartnerRequestToJSON(requestParameters['updatePartnerRequest']),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => PartnerUpdateResultFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Admin only. Every field is optional; send the ones to change. The profile fields (`name`, `email`, `webhookUrl`, `allowedDomains`, `billingSettings`) are stored on the partner. `autoReloadAmount` and `autoReloadThreshold` are stored with the partner\'s auto-reload settings, which are a different record: an edit to one of them keeps the other and the rest of the configuration. `creditBalance` is a **target balance**, not a stored value. The wallet is moved by the difference between it and the balance the ledger holds now, as a ledger row, by the same keyed path `POST /admin/partners/{partnerId}/credits` uses. So a request that sets it **must** carry an `Idempotency-Key` (a request without one is refused with 400 and changes nothing, not even the fields beside it), a top-up is held to the same ceiling of $100,000 per operation, and a retry with the same key replays the first result instead of moving the wallet twice. `notes` becomes the reason on that ledger row. A request that sets no balance needs no key. `isActive` only flips the switch, and goes through the same check as `PUT /admin/partners/{partnerId}/status`: activating a partner that was never activated is refused with 409 `PARTNER_NOT_READY` until its contract and storage destination are in place, and the fields beside it are not written when it is refused. To pause a partner with a recorded reason, or to resume one so that everything the pause turned off is restored, use `PUT /admin/partners/{partnerId}/status`. The response is the partner as it is after the edit; `creditAdjustment` and `autoReload` report what was done to the wallet and the settings, when the request touched them.
+     * Edit a partner\'s profile, wallet balance or auto-reload settings
+     */
+    updatePartner(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.updatePartnerRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Admin only. Sets the partner\'s standing (the `status` field every partner response carries). - `active` activates a new partner, or resumes a paused one: it is switched on, and a suspension\'s reason   and time are cleared. **Activating a partner that was never activated (or was deactivated) is refused with   409 `PARTNER_NOT_READY` until a contract is in force and a verified storage destination is set**   (`error.details.requirements` lists each, and `GET /admin/partners/{partnerId}/activation` reads them   without changing anything). Resuming a paused partner is never held up by that. It also records the   partner plan on the partner\'s administrator again if that was missing (a partner created before the plan   was recorded, or whose write failed); if that could not be done the partner is still reinstated and   `warnings` says so. - `inactive` switches the partner off without a reason; a suspension\'s reason and time are cleared, so   a partner moved from suspended to inactive is no longer reported as suspended. - `suspended` is the pause: it switches the partner off and records `reason` (default `Suspended by   admin`) and the time. It is manual only. An unpaid invoice is chased and reported to the administrators,   but never pauses a partner by itself.  While a partner is not `active` it is unusable, and what it published is not served: its embeds answer as if they did not exist, editor sessions are refused, its customers cannot create or generate anything, and every write or generation by its API key is refused with 403 `PARTNER_SUSPENDED` (or `PARTNER_INACTIVE`). This takes hold within 15 seconds at most, on every instance. The partner\'s own administrator can still sign in and use billing, invoices, credits, the contract and notifications. Resuming the partner restores everything, with no new token for a customer. A person who administers two partners is served while either is active, and an administrator account that also holds a subscription of its own is served on that. Sending the standing the partner already has is accepted; for `suspended` it replaces the recorded reason and time.
+     * Activate, deactivate or suspend a partner
+     */
+    updatePartnerStatusRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['partnerId'] == null) {
+                throw new runtime.RequiredError('partnerId', 'Required parameter "partnerId" was null or undefined when calling updatePartnerStatus().');
+            }
+            if (requestParameters['updatePartnerStatusRequest'] == null) {
+                throw new runtime.RequiredError('updatePartnerStatusRequest', 'Required parameter "updatePartnerStatusRequest" was null or undefined when calling updatePartnerStatus().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/admin/partners/{partnerId}/status`.replace(`{${"partnerId"}}`, encodeURIComponent(String(requestParameters['partnerId']))),
+                method: 'PUT',
+                headers: headerParameters,
+                query: queryParameters,
+                body: UpdatePartnerStatusRequestToJSON(requestParameters['updatePartnerStatusRequest']),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => PartnerWithWarningsFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Admin only. Sets the partner\'s standing (the `status` field every partner response carries). - `active` activates a new partner, or resumes a paused one: it is switched on, and a suspension\'s reason   and time are cleared. **Activating a partner that was never activated (or was deactivated) is refused with   409 `PARTNER_NOT_READY` until a contract is in force and a verified storage destination is set**   (`error.details.requirements` lists each, and `GET /admin/partners/{partnerId}/activation` reads them   without changing anything). Resuming a paused partner is never held up by that. It also records the   partner plan on the partner\'s administrator again if that was missing (a partner created before the plan   was recorded, or whose write failed); if that could not be done the partner is still reinstated and   `warnings` says so. - `inactive` switches the partner off without a reason; a suspension\'s reason and time are cleared, so   a partner moved from suspended to inactive is no longer reported as suspended. - `suspended` is the pause: it switches the partner off and records `reason` (default `Suspended by   admin`) and the time. It is manual only. An unpaid invoice is chased and reported to the administrators,   but never pauses a partner by itself.  While a partner is not `active` it is unusable, and what it published is not served: its embeds answer as if they did not exist, editor sessions are refused, its customers cannot create or generate anything, and every write or generation by its API key is refused with 403 `PARTNER_SUSPENDED` (or `PARTNER_INACTIVE`). This takes hold within 15 seconds at most, on every instance. The partner\'s own administrator can still sign in and use billing, invoices, credits, the contract and notifications. Resuming the partner restores everything, with no new token for a customer. A person who administers two partners is served while either is active, and an administrator account that also holds a subscription of its own is served on that. Sending the standing the partner already has is accepted; for `suspended` it replaces the recorded reason and time.
+     * Activate, deactivate or suspend a partner
+     */
+    updatePartnerStatus(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.updatePartnerStatusRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
 }
+/**
+ * @export
+ */
+export const GetPartnerBillingReportIncludeTransactionsEnum = {
+    True: 'true',
+    False: 'false'
+};
+/**
+ * @export
+ */
+export const ListAdminWidgetsScopeEnum = {
+    Mine: 'mine',
+    All: 'all'
+};
+/**
+ * @export
+ */
+export const ListAdminWidgetsPresetEnum = {
+    True: 'true',
+    False: 'false'
+};
+/**
+ * @export
+ */
+export const ListPartnersStatusEnum = {
+    Active: 'active',
+    Inactive: 'inactive',
+    Suspended: 'suspended'
+};