@emilgroup/tenant-sdk 1.42.1-beta.30 → 1.42.1-beta.31

package/README.md

@@ -17,11 +17,11 @@ Although this package can be used in both TypeScript and JavaScript, it is inten
 Navigate to the folder of your consuming project and run one of the following commands:
 
 ```
-npm install @emilgroup/tenant-sdk@1.42.1-beta.30 --save
+npm install @emilgroup/tenant-sdk@1.42.1-beta.31 --save
 ```
 or 
 ```
-yarn add @emilgroup/tenant-sdk@1.42.1-beta.30
+yarn add @emilgroup/tenant-sdk@1.42.1-beta.31
 ```
 
 And then you can import `UsersApi`.

package/api/test-tenant-pool-api.ts

@@ -125,6 +125,51 @@ export const TestTenantPoolApiAxiosParamCreator = function (configuration?: Conf
 
 
     
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Operator escape hatch for a pool tenant stuck in reset_failed: forces it straight to available, clearing lease/cleanup-job state, without re-running cleanup -- unlike retrigger-cleanup. Only use this once the underlying data has been handled some other way, since it skips cleanup entirely. Refused for any other status.  **Required Permissions**  \"tenant-management.tenants.update\"
+         * @summary Force a pool tenant back to available
+         * @param {string} tenantSlug The slug of the tenant it was registered under.
+         * @param {string} [authorization] Bearer Token
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        forceAvailable: async (tenantSlug: string, authorization?: string, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'tenantSlug' is not null or undefined
+            assertParamExists('forceAvailable', 'tenantSlug', tenantSlug)
+            const localVarPath = `/tenantservice/v1/test-tenant-pool/{tenantSlug}/force-available`
+                .replace(`{${"tenantSlug"}}`, encodeURIComponent(String(tenantSlug)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            let baseAccessToken;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+                baseAccessToken = configuration.accessToken;
+            }
+
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication bearer required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration)
+
+            if (authorization !== undefined && authorization !== null || baseAccessToken !== undefined && baseAccessToken !== null) {
+                localVarHeaderParameter['Authorization'] = String(authorization ? authorization : baseAccessToken);
+            }
+
+
+    
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
@@ -620,6 +665,18 @@ export const TestTenantPoolApiFp = function(configuration?: Configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.deregister(tenantSlug, authorization, options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
+        /**
+         * Operator escape hatch for a pool tenant stuck in reset_failed: forces it straight to available, clearing lease/cleanup-job state, without re-running cleanup -- unlike retrigger-cleanup. Only use this once the underlying data has been handled some other way, since it skips cleanup entirely. Refused for any other status.  **Required Permissions**  \"tenant-management.tenants.update\"
+         * @summary Force a pool tenant back to available
+         * @param {string} tenantSlug The slug of the tenant it was registered under.
+         * @param {string} [authorization] Bearer Token
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async forceAvailable(tenantSlug: string, authorization?: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PoolTenantResponseClass>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.forceAvailable(tenantSlug, authorization, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
         /**
          * Returns the single, shared configuration describing which database entities get hard-deleted when a pool tenant is cleaned up after release.  **Required Permissions**  \"tenant-management.tenants.view\"
          * @summary Read the shared cleanup registry
@@ -771,6 +828,17 @@ export const TestTenantPoolApiFactory = function (configuration?: Configuration,
         deregister(tenantSlug: string, authorization?: string, options?: any): AxiosPromise<void> {
             return localVarFp.deregister(tenantSlug, authorization, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Operator escape hatch for a pool tenant stuck in reset_failed: forces it straight to available, clearing lease/cleanup-job state, without re-running cleanup -- unlike retrigger-cleanup. Only use this once the underlying data has been handled some other way, since it skips cleanup entirely. Refused for any other status.  **Required Permissions**  \"tenant-management.tenants.update\"
+         * @summary Force a pool tenant back to available
+         * @param {string} tenantSlug The slug of the tenant it was registered under.
+         * @param {string} [authorization] Bearer Token
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        forceAvailable(tenantSlug: string, authorization?: string, options?: any): AxiosPromise<PoolTenantResponseClass> {
+            return localVarFp.forceAvailable(tenantSlug, authorization, options).then((request) => request(axios, basePath));
+        },
         /**
          * Returns the single, shared configuration describing which database entities get hard-deleted when a pool tenant is cleaned up after release.  **Required Permissions**  \"tenant-management.tenants.view\"
          * @summary Read the shared cleanup registry
@@ -925,6 +993,27 @@ export interface TestTenantPoolApiDeregisterRequest {
     readonly authorization?: string
 }
 
+/**
+ * Request parameters for forceAvailable operation in TestTenantPoolApi.
+ * @export
+ * @interface TestTenantPoolApiForceAvailableRequest
+ */
+export interface TestTenantPoolApiForceAvailableRequest {
+    /**
+     * The slug of the tenant it was registered under.
+     * @type {string}
+     * @memberof TestTenantPoolApiForceAvailable
+     */
+    readonly tenantSlug: string
+
+    /**
+     * Bearer Token
+     * @type {string}
+     * @memberof TestTenantPoolApiForceAvailable
+     */
+    readonly authorization?: string
+}
+
 /**
  * Request parameters for getCleanupRegistry operation in TestTenantPoolApi.
  * @export
@@ -1159,6 +1248,18 @@ export class TestTenantPoolApi extends BaseAPI {
         return TestTenantPoolApiFp(this.configuration).deregister(requestParameters.tenantSlug, requestParameters.authorization, options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * Operator escape hatch for a pool tenant stuck in reset_failed: forces it straight to available, clearing lease/cleanup-job state, without re-running cleanup -- unlike retrigger-cleanup. Only use this once the underlying data has been handled some other way, since it skips cleanup entirely. Refused for any other status.  **Required Permissions**  \"tenant-management.tenants.update\"
+     * @summary Force a pool tenant back to available
+     * @param {TestTenantPoolApiForceAvailableRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof TestTenantPoolApi
+     */
+    public forceAvailable(requestParameters: TestTenantPoolApiForceAvailableRequest, options?: AxiosRequestConfig) {
+        return TestTenantPoolApiFp(this.configuration).forceAvailable(requestParameters.tenantSlug, requestParameters.authorization, options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * Returns the single, shared configuration describing which database entities get hard-deleted when a pool tenant is cleaned up after release.  **Required Permissions**  \"tenant-management.tenants.view\"
      * @summary Read the shared cleanup registry

package/dist/api/test-tenant-pool-api.d.ts

@@ -43,6 +43,15 @@ export declare const TestTenantPoolApiAxiosParamCreator: (configuration?: Config
      * @throws {RequiredError}
      */
     deregister: (tenantSlug: string, authorization?: string, options?: AxiosRequestConfig) => Promise<RequestArgs>;
+    /**
+     * Operator escape hatch for a pool tenant stuck in reset_failed: forces it straight to available, clearing lease/cleanup-job state, without re-running cleanup -- unlike retrigger-cleanup. Only use this once the underlying data has been handled some other way, since it skips cleanup entirely. Refused for any other status.  **Required Permissions**  \"tenant-management.tenants.update\"
+     * @summary Force a pool tenant back to available
+     * @param {string} tenantSlug The slug of the tenant it was registered under.
+     * @param {string} [authorization] Bearer Token
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    forceAvailable: (tenantSlug: string, authorization?: string, options?: AxiosRequestConfig) => Promise<RequestArgs>;
     /**
      * Returns the single, shared configuration describing which database entities get hard-deleted when a pool tenant is cleaned up after release.  **Required Permissions**  \"tenant-management.tenants.view\"
      * @summary Read the shared cleanup registry
@@ -156,6 +165,15 @@ export declare const TestTenantPoolApiFp: (configuration?: Configuration) => {
      * @throws {RequiredError}
      */
     deregister(tenantSlug: string, authorization?: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
+    /**
+     * Operator escape hatch for a pool tenant stuck in reset_failed: forces it straight to available, clearing lease/cleanup-job state, without re-running cleanup -- unlike retrigger-cleanup. Only use this once the underlying data has been handled some other way, since it skips cleanup entirely. Refused for any other status.  **Required Permissions**  \"tenant-management.tenants.update\"
+     * @summary Force a pool tenant back to available
+     * @param {string} tenantSlug The slug of the tenant it was registered under.
+     * @param {string} [authorization] Bearer Token
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    forceAvailable(tenantSlug: string, authorization?: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PoolTenantResponseClass>>;
     /**
      * Returns the single, shared configuration describing which database entities get hard-deleted when a pool tenant is cleaned up after release.  **Required Permissions**  \"tenant-management.tenants.view\"
      * @summary Read the shared cleanup registry
@@ -269,6 +287,15 @@ export declare const TestTenantPoolApiFactory: (configuration?: Configuration, b
      * @throws {RequiredError}
      */
     deregister(tenantSlug: string, authorization?: string, options?: any): AxiosPromise<void>;
+    /**
+     * Operator escape hatch for a pool tenant stuck in reset_failed: forces it straight to available, clearing lease/cleanup-job state, without re-running cleanup -- unlike retrigger-cleanup. Only use this once the underlying data has been handled some other way, since it skips cleanup entirely. Refused for any other status.  **Required Permissions**  \"tenant-management.tenants.update\"
+     * @summary Force a pool tenant back to available
+     * @param {string} tenantSlug The slug of the tenant it was registered under.
+     * @param {string} [authorization] Bearer Token
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    forceAvailable(tenantSlug: string, authorization?: string, options?: any): AxiosPromise<PoolTenantResponseClass>;
     /**
      * Returns the single, shared configuration describing which database entities get hard-deleted when a pool tenant is cleaned up after release.  **Required Permissions**  \"tenant-management.tenants.view\"
      * @summary Read the shared cleanup registry
@@ -397,6 +424,25 @@ export interface TestTenantPoolApiDeregisterRequest {
      */
     readonly authorization?: string;
 }
+/**
+ * Request parameters for forceAvailable operation in TestTenantPoolApi.
+ * @export
+ * @interface TestTenantPoolApiForceAvailableRequest
+ */
+export interface TestTenantPoolApiForceAvailableRequest {
+    /**
+     * The slug of the tenant it was registered under.
+     * @type {string}
+     * @memberof TestTenantPoolApiForceAvailable
+     */
+    readonly tenantSlug: string;
+    /**
+     * Bearer Token
+     * @type {string}
+     * @memberof TestTenantPoolApiForceAvailable
+     */
+    readonly authorization?: string;
+}
 /**
  * Request parameters for getCleanupRegistry operation in TestTenantPoolApi.
  * @export
@@ -606,6 +652,15 @@ export declare class TestTenantPoolApi extends BaseAPI {
      * @memberof TestTenantPoolApi
      */
     deregister(requestParameters: TestTenantPoolApiDeregisterRequest, options?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any, {}>>;
+    /**
+     * Operator escape hatch for a pool tenant stuck in reset_failed: forces it straight to available, clearing lease/cleanup-job state, without re-running cleanup -- unlike retrigger-cleanup. Only use this once the underlying data has been handled some other way, since it skips cleanup entirely. Refused for any other status.  **Required Permissions**  \"tenant-management.tenants.update\"
+     * @summary Force a pool tenant back to available
+     * @param {TestTenantPoolApiForceAvailableRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof TestTenantPoolApi
+     */
+    forceAvailable(requestParameters: TestTenantPoolApiForceAvailableRequest, options?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<PoolTenantResponseClass, any, {}>>;
     /**
      * Returns the single, shared configuration describing which database entities get hard-deleted when a pool tenant is cleaned up after release.  **Required Permissions**  \"tenant-management.tenants.view\"
      * @summary Read the shared cleanup registry

package/dist/api/test-tenant-pool-api.js

@@ -189,6 +189,54 @@ var TestTenantPoolApiAxiosParamCreator = function (configuration) {
                 });
             });
         },
+        /**
+         * Operator escape hatch for a pool tenant stuck in reset_failed: forces it straight to available, clearing lease/cleanup-job state, without re-running cleanup -- unlike retrigger-cleanup. Only use this once the underlying data has been handled some other way, since it skips cleanup entirely. Refused for any other status.  **Required Permissions**  \"tenant-management.tenants.update\"
+         * @summary Force a pool tenant back to available
+         * @param {string} tenantSlug The slug of the tenant it was registered under.
+         * @param {string} [authorization] Bearer Token
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        forceAvailable: function (tenantSlug, authorization, options) {
+            if (options === void 0) { options = {}; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var localVarPath, localVarUrlObj, baseOptions, baseAccessToken, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            // verify required parameter 'tenantSlug' is not null or undefined
+                            (0, common_1.assertParamExists)('forceAvailable', 'tenantSlug', tenantSlug);
+                            localVarPath = "/tenantservice/v1/test-tenant-pool/{tenantSlug}/force-available"
+                                .replace("{".concat("tenantSlug", "}"), encodeURIComponent(String(tenantSlug)));
+                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
+                            if (configuration) {
+                                baseOptions = configuration.baseOptions;
+                                baseAccessToken = configuration.accessToken;
+                            }
+                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), options);
+                            localVarHeaderParameter = {};
+                            localVarQueryParameter = {};
+                            // authentication bearer required
+                            // http bearer authentication required
+                            return [4 /*yield*/, (0, common_1.setBearerAuthToObject)(localVarHeaderParameter, configuration)];
+                        case 1:
+                            // authentication bearer required
+                            // http bearer authentication required
+                            _a.sent();
+                            if (authorization !== undefined && authorization !== null || baseAccessToken !== undefined && baseAccessToken !== null) {
+                                localVarHeaderParameter['Authorization'] = String(authorization ? authorization : baseAccessToken);
+                            }
+                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
+                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), options.headers);
+                            return [2 /*return*/, {
+                                    url: (0, common_1.toPathString)(localVarUrlObj),
+                                    options: localVarRequestOptions,
+                                }];
+                    }
+                });
+            });
+        },
         /**
          * Returns the single, shared configuration describing which database entities get hard-deleted when a pool tenant is cleaned up after release.  **Required Permissions**  \"tenant-management.tenants.view\"
          * @summary Read the shared cleanup registry
@@ -720,6 +768,27 @@ var TestTenantPoolApiFp = function (configuration) {
                 });
             });
         },
+        /**
+         * Operator escape hatch for a pool tenant stuck in reset_failed: forces it straight to available, clearing lease/cleanup-job state, without re-running cleanup -- unlike retrigger-cleanup. Only use this once the underlying data has been handled some other way, since it skips cleanup entirely. Refused for any other status.  **Required Permissions**  \"tenant-management.tenants.update\"
+         * @summary Force a pool tenant back to available
+         * @param {string} tenantSlug The slug of the tenant it was registered under.
+         * @param {string} [authorization] Bearer Token
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        forceAvailable: function (tenantSlug, authorization, options) {
+            return __awaiter(this, void 0, void 0, function () {
+                var localVarAxiosArgs;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.forceAvailable(tenantSlug, authorization, options)];
+                        case 1:
+                            localVarAxiosArgs = _a.sent();
+                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
+                    }
+                });
+            });
+        },
         /**
          * Returns the single, shared configuration describing which database entities get hard-deleted when a pool tenant is cleaned up after release.  **Required Permissions**  \"tenant-management.tenants.view\"
          * @summary Read the shared cleanup registry
@@ -961,6 +1030,17 @@ var TestTenantPoolApiFactory = function (configuration, basePath, axios) {
         deregister: function (tenantSlug, authorization, options) {
             return localVarFp.deregister(tenantSlug, authorization, options).then(function (request) { return request(axios, basePath); });
         },
+        /**
+         * Operator escape hatch for a pool tenant stuck in reset_failed: forces it straight to available, clearing lease/cleanup-job state, without re-running cleanup -- unlike retrigger-cleanup. Only use this once the underlying data has been handled some other way, since it skips cleanup entirely. Refused for any other status.  **Required Permissions**  \"tenant-management.tenants.update\"
+         * @summary Force a pool tenant back to available
+         * @param {string} tenantSlug The slug of the tenant it was registered under.
+         * @param {string} [authorization] Bearer Token
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        forceAvailable: function (tenantSlug, authorization, options) {
+            return localVarFp.forceAvailable(tenantSlug, authorization, options).then(function (request) { return request(axios, basePath); });
+        },
         /**
          * Returns the single, shared configuration describing which database entities get hard-deleted when a pool tenant is cleaned up after release.  **Required Permissions**  \"tenant-management.tenants.view\"
          * @summary Read the shared cleanup registry
@@ -1108,6 +1188,18 @@ var TestTenantPoolApi = /** @class */ (function (_super) {
         var _this = this;
         return (0, exports.TestTenantPoolApiFp)(this.configuration).deregister(requestParameters.tenantSlug, requestParameters.authorization, options).then(function (request) { return request(_this.axios, _this.basePath); });
     };
+    /**
+     * Operator escape hatch for a pool tenant stuck in reset_failed: forces it straight to available, clearing lease/cleanup-job state, without re-running cleanup -- unlike retrigger-cleanup. Only use this once the underlying data has been handled some other way, since it skips cleanup entirely. Refused for any other status.  **Required Permissions**  \"tenant-management.tenants.update\"
+     * @summary Force a pool tenant back to available
+     * @param {TestTenantPoolApiForceAvailableRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof TestTenantPoolApi
+     */
+    TestTenantPoolApi.prototype.forceAvailable = function (requestParameters, options) {
+        var _this = this;
+        return (0, exports.TestTenantPoolApiFp)(this.configuration).forceAvailable(requestParameters.tenantSlug, requestParameters.authorization, options).then(function (request) { return request(_this.axios, _this.basePath); });
+    };
     /**
      * Returns the single, shared configuration describing which database entities get hard-deleted when a pool tenant is cleaned up after release.  **Required Permissions**  \"tenant-management.tenants.view\"
      * @summary Read the shared cleanup registry

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emilgroup/tenant-sdk",
-  "version": "1.42.1-beta.30",
+  "version": "1.42.1-beta.31",
   "description": "OpenAPI client for @emilgroup/tenant-sdk",
   "author": "OpenAPI-Generator Contributors",
   "keywords": [