@hydradb/sdk 2.0.0 → 2.1.0

package/dist/api/resources/{tenants → databases}/client/Client.js

@@ -34,7 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TenantsClient = void 0;
+exports.DatabasesClient = void 0;
 const BaseClient_js_1 = require("../../../../BaseClient.js");
 const headers_js_1 = require("../../../../core/headers.js");
 const core = __importStar(require("../../../../core/index.js"));
@@ -43,23 +43,19 @@ const handleNonStatusCodeError_js_1 = require("../../../../errors/handleNonStatu
 const errors = __importStar(require("../../../../errors/index.js"));
 const serializers = __importStar(require("../../../../serialization/index.js"));
 const HydraDB = __importStar(require("../../../index.js"));
-class TenantsClient {
+class DatabasesClient {
     constructor(options) {
         this._options = (0, BaseClient_js_1.normalizeClientOptionsWithAuth)(options);
     }
     /**
-     * @param {TenantsClient.RequestOptions} requestOptions - Request-specific configuration.
+     * List all databases for the authenticated user
+     *
+     * @param {DatabasesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
-     * @throws {@link HydraDB.BadRequestError}
-     * @throws {@link HydraDB.UnauthorizedError}
-     * @throws {@link HydraDB.ForbiddenError}
-     * @throws {@link HydraDB.NotFoundError}
-     * @throws {@link HydraDB.UnprocessableEntityError}
      * @throws {@link HydraDB.InternalServerError}
-     * @throws {@link HydraDB.ServiceUnavailableError}
      *
      * @example
-     *     await client.tenants.list()
+     *     await client.databases.list()
      */
     list(requestOptions) {
         return core.HttpResponsePromise.fromPromise(this.__list(requestOptions));
@@ -70,7 +66,7 @@ class TenantsClient {
         const _response = await core.fetcher({
             url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
                 (await core.Supplier.get(this._options.environment)) ??
-                environments.HydraDBEnvironment.HydradDb, "tenants"),
+                environments.HydraDBEnvironment.Default, "databases"),
             method: "GET",
             headers: _headers,
             queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
@@ -82,7 +78,7 @@ class TenantsClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.TenantListApiResponse.parseOrThrow(_response.body, {
+                data: serializers.HandlerEnvelopeTenantsTenantIdsResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -94,20 +90,14 @@ class TenantsClient {
         }
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
-                case 400:
-                    throw new HydraDB.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new HydraDB.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new HydraDB.ForbiddenError(_response.error.body, _response.rawResponse);
-                case 404:
-                    throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new HydraDB.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 500:
-                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
-                case 503:
-                    throw new HydraDB.ServiceUnavailableError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.InternalServerError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
                 default:
                     throw new errors.HydraDBError({
                         statusCode: _response.error.statusCode,
@@ -116,41 +106,38 @@ class TenantsClient {
                     });
             }
         }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/tenants");
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/databases");
     }
     /**
-     * @param {HydraDB.TenantCreateRequest} request
-     * @param {TenantsClient.RequestOptions} requestOptions - Request-specific configuration.
+     * Create a new database with optional custom metadata schema
+     *
+     * @param {HydraDB.TenantsTenantCreateRequest} request
+     * @param {DatabasesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link HydraDB.BadRequestError}
-     * @throws {@link HydraDB.UnauthorizedError}
      * @throws {@link HydraDB.ForbiddenError}
-     * @throws {@link HydraDB.NotFoundError}
-     * @throws {@link HydraDB.UnprocessableEntityError}
+     * @throws {@link HydraDB.ConflictError}
      * @throws {@link HydraDB.InternalServerError}
-     * @throws {@link HydraDB.ServiceUnavailableError}
      *
      * @example
-     *     await client.tenants.create({
-     *         tenantId: "tenant_1234"
-     *     })
+     *     await client.databases.create()
      */
-    create(request, requestOptions) {
+    create(request = {}, requestOptions) {
         return core.HttpResponsePromise.fromPromise(this.__create(request, requestOptions));
     }
-    async __create(request, requestOptions) {
+    async __create(request = {}, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ "API-Version": requestOptions?.apiVersion ?? this._options?.apiVersion ?? "2" }), requestOptions?.headers);
         const _response = await core.fetcher({
             url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
                 (await core.Supplier.get(this._options.environment)) ??
-                environments.HydraDBEnvironment.HydradDb, "tenants"),
+                environments.HydraDBEnvironment.Default, "databases"),
             method: "POST",
             headers: _headers,
             contentType: "application/json",
             queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
             requestType: "json",
-            body: serializers.TenantCreateRequest.jsonOrThrow(request, {
+            body: serializers.TenantsTenantCreateRequest.jsonOrThrow(request, {
                 unrecognizedObjectKeys: "strip",
                 omitUndefined: true,
             }),
@@ -162,7 +149,7 @@ class TenantsClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.TenantCreateApiResponse.parseOrThrow(_response.body, {
+                data: serializers.HandlerEnvelopeTenantsTenantCreateAcceptedResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -175,19 +162,37 @@ class TenantsClient {
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
                 case 400:
-                    throw new HydraDB.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new HydraDB.UnauthorizedError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.BadRequestError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
                 case 403:
-                    throw new HydraDB.ForbiddenError(_response.error.body, _response.rawResponse);
-                case 404:
-                    throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new HydraDB.UnprocessableEntityError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.ForbiddenError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
+                case 409:
+                    throw new HydraDB.ConflictError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
                 case 500:
-                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
-                case 503:
-                    throw new HydraDB.ServiceUnavailableError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.InternalServerError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
                 default:
                     throw new errors.HydraDBError({
                         statusCode: _response.error.statusCode,
@@ -196,39 +201,37 @@ class TenantsClient {
                     });
             }
         }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/tenants");
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/databases");
     }
     /**
-     * @param {HydraDB.DeleteTenantsRequest} request
-     * @param {TenantsClient.RequestOptions} requestOptions - Request-specific configuration.
+     * Delete a database and all associated data
+     *
+     * @param {HydraDB.DeleteDatabasesRequest} request
+     * @param {DatabasesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link HydraDB.BadRequestError}
-     * @throws {@link HydraDB.UnauthorizedError}
-     * @throws {@link HydraDB.ForbiddenError}
      * @throws {@link HydraDB.NotFoundError}
-     * @throws {@link HydraDB.UnprocessableEntityError}
      * @throws {@link HydraDB.InternalServerError}
-     * @throws {@link HydraDB.ServiceUnavailableError}
      *
      * @example
-     *     await client.tenants.delete({
-     *         tenantId: "tenant_1234"
+     *     await client.databases.delete({
+     *         database: "database"
      *     })
      */
     delete(request, requestOptions) {
         return core.HttpResponsePromise.fromPromise(this.__delete(request, requestOptions));
     }
     async __delete(request, requestOptions) {
-        const { tenantId } = request;
+        const { database } = request;
         const _queryParams = {
-            tenant_id: tenantId,
+            database,
         };
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ "API-Version": requestOptions?.apiVersion ?? this._options?.apiVersion ?? "2" }), requestOptions?.headers);
         const _response = await core.fetcher({
             url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
                 (await core.Supplier.get(this._options.environment)) ??
-                environments.HydraDBEnvironment.HydradDb, "tenants"),
+                environments.HydraDBEnvironment.Default, "databases"),
             method: "DELETE",
             headers: _headers,
             queryString: core.url
@@ -244,7 +247,7 @@ class TenantsClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.TenantDeleteApiResponse.parseOrThrow(_response.body, {
+                data: serializers.HandlerEnvelopeTenantsTenantDeleteResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -257,19 +260,29 @@ class TenantsClient {
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
                 case 400:
-                    throw new HydraDB.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new HydraDB.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new HydraDB.ForbiddenError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.BadRequestError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
                 case 404:
-                    throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new HydraDB.UnprocessableEntityError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.NotFoundError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
                 case 500:
-                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
-                case 503:
-                    throw new HydraDB.ServiceUnavailableError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.InternalServerError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
                 default:
                     throw new errors.HydraDBError({
                         statusCode: _response.error.statusCode,
@@ -278,39 +291,37 @@ class TenantsClient {
                     });
             }
         }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "DELETE", "/tenants");
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "DELETE", "/databases");
     }
     /**
-     * @param {HydraDB.StatusTenantsRequest} request
-     * @param {TenantsClient.RequestOptions} requestOptions - Request-specific configuration.
+     * List all collections for a given database
+     *
+     * @param {HydraDB.CollectionsDatabasesRequest} request
+     * @param {DatabasesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link HydraDB.BadRequestError}
-     * @throws {@link HydraDB.UnauthorizedError}
-     * @throws {@link HydraDB.ForbiddenError}
      * @throws {@link HydraDB.NotFoundError}
-     * @throws {@link HydraDB.UnprocessableEntityError}
      * @throws {@link HydraDB.InternalServerError}
-     * @throws {@link HydraDB.ServiceUnavailableError}
      *
      * @example
-     *     await client.tenants.status({
-     *         tenantId: "tenant_1234"
+     *     await client.databases.collections({
+     *         database: "database"
      *     })
      */
-    status(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__status(request, requestOptions));
+    collections(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__collections(request, requestOptions));
     }
-    async __status(request, requestOptions) {
-        const { tenantId } = request;
+    async __collections(request, requestOptions) {
+        const { database } = request;
         const _queryParams = {
-            tenant_id: tenantId,
+            database,
         };
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ "API-Version": requestOptions?.apiVersion ?? this._options?.apiVersion ?? "2" }), requestOptions?.headers);
         const _response = await core.fetcher({
             url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
                 (await core.Supplier.get(this._options.environment)) ??
-                environments.HydraDBEnvironment.HydradDb, "tenants/status"),
+                environments.HydraDBEnvironment.Default, "databases/collections"),
             method: "GET",
             headers: _headers,
             queryString: core.url
@@ -326,7 +337,7 @@ class TenantsClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.TenantInfraStatusApiResponse.parseOrThrow(_response.body, {
+                data: serializers.HandlerEnvelopeTenantsSubTenantIdsResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -339,19 +350,29 @@ class TenantsClient {
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
                 case 400:
-                    throw new HydraDB.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new HydraDB.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new HydraDB.ForbiddenError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.BadRequestError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
                 case 404:
-                    throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new HydraDB.UnprocessableEntityError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.NotFoundError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
                 case 500:
-                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
-                case 503:
-                    throw new HydraDB.ServiceUnavailableError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.InternalServerError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
                 default:
                     throw new errors.HydraDBError({
                         statusCode: _response.error.statusCode,
@@ -360,39 +381,37 @@ class TenantsClient {
                     });
             }
         }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/tenants/status");
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/databases/collections");
     }
     /**
-     * @param {HydraDB.SubTenantsTenantsRequest} request
-     * @param {TenantsClient.RequestOptions} requestOptions - Request-specific configuration.
+     * Get collection statistics for a database
+     *
+     * @param {HydraDB.StatsDatabasesRequest} request
+     * @param {DatabasesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link HydraDB.BadRequestError}
-     * @throws {@link HydraDB.UnauthorizedError}
-     * @throws {@link HydraDB.ForbiddenError}
      * @throws {@link HydraDB.NotFoundError}
-     * @throws {@link HydraDB.UnprocessableEntityError}
      * @throws {@link HydraDB.InternalServerError}
-     * @throws {@link HydraDB.ServiceUnavailableError}
      *
      * @example
-     *     await client.tenants.subTenants({
-     *         tenantId: "tenant_1234"
+     *     await client.databases.stats({
+     *         database: "database"
      *     })
      */
-    subTenants(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__subTenants(request, requestOptions));
+    stats(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__stats(request, requestOptions));
     }
-    async __subTenants(request, requestOptions) {
-        const { tenantId } = request;
+    async __stats(request, requestOptions) {
+        const { database } = request;
         const _queryParams = {
-            tenant_id: tenantId,
+            database,
         };
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ "API-Version": requestOptions?.apiVersion ?? this._options?.apiVersion ?? "2" }), requestOptions?.headers);
         const _response = await core.fetcher({
             url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
                 (await core.Supplier.get(this._options.environment)) ??
-                environments.HydraDBEnvironment.HydradDb, "tenants/sub-tenants"),
+                environments.HydraDBEnvironment.Default, "databases/stats"),
             method: "GET",
             headers: _headers,
             queryString: core.url
@@ -408,7 +427,7 @@ class TenantsClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.TenantSubTenantsApiResponse.parseOrThrow(_response.body, {
+                data: serializers.HandlerEnvelopeTenantsTenantStatsResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -421,19 +440,29 @@ class TenantsClient {
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
                 case 400:
-                    throw new HydraDB.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new HydraDB.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new HydraDB.ForbiddenError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.BadRequestError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
                 case 404:
-                    throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new HydraDB.UnprocessableEntityError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.NotFoundError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
                 case 500:
-                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
-                case 503:
-                    throw new HydraDB.ServiceUnavailableError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.InternalServerError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
                 default:
                     throw new errors.HydraDBError({
                         statusCode: _response.error.statusCode,
@@ -442,39 +471,37 @@ class TenantsClient {
                     });
             }
         }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/tenants/sub-tenants");
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/databases/stats");
     }
     /**
-     * @param {HydraDB.StatsTenantsRequest} request
-     * @param {TenantsClient.RequestOptions} requestOptions - Request-specific configuration.
+     * Check the infrastructure provisioning status for a database
+     *
+     * @param {HydraDB.StatusDatabasesRequest} request
+     * @param {DatabasesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link HydraDB.BadRequestError}
-     * @throws {@link HydraDB.UnauthorizedError}
-     * @throws {@link HydraDB.ForbiddenError}
      * @throws {@link HydraDB.NotFoundError}
-     * @throws {@link HydraDB.UnprocessableEntityError}
      * @throws {@link HydraDB.InternalServerError}
-     * @throws {@link HydraDB.ServiceUnavailableError}
      *
      * @example
-     *     await client.tenants.stats({
-     *         tenantId: "tenant_1234"
+     *     await client.databases.status({
+     *         database: "database"
      *     })
      */
-    stats(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__stats(request, requestOptions));
+    status(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__status(request, requestOptions));
     }
-    async __stats(request, requestOptions) {
-        const { tenantId } = request;
+    async __status(request, requestOptions) {
+        const { database } = request;
         const _queryParams = {
-            tenant_id: tenantId,
+            database,
         };
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ "API-Version": requestOptions?.apiVersion ?? this._options?.apiVersion ?? "2" }), requestOptions?.headers);
         const _response = await core.fetcher({
             url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
                 (await core.Supplier.get(this._options.environment)) ??
-                environments.HydraDBEnvironment.HydradDb, "tenants/stats"),
+                environments.HydraDBEnvironment.Default, "databases/status"),
             method: "GET",
             headers: _headers,
             queryString: core.url
@@ -490,7 +517,7 @@ class TenantsClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.TenantStatsApiResponse.parseOrThrow(_response.body, {
+                data: serializers.HandlerEnvelopeTenantsInfraStatusResponseV2.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -503,19 +530,29 @@ class TenantsClient {
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
                 case 400:
-                    throw new HydraDB.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new HydraDB.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new HydraDB.ForbiddenError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.BadRequestError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
                 case 404:
-                    throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new HydraDB.UnprocessableEntityError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.NotFoundError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
                 case 500:
-                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
-                case 503:
-                    throw new HydraDB.ServiceUnavailableError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.InternalServerError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
                 default:
                     throw new errors.HydraDBError({
                         statusCode: _response.error.statusCode,
@@ -524,7 +561,7 @@ class TenantsClient {
                     });
             }
         }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/tenants/stats");
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/databases/status");
     }
 }
-exports.TenantsClient = TenantsClient;
+exports.DatabasesClient = DatabasesClient;

package/dist/api/resources/databases/client/requests/CollectionsDatabasesRequest.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @example
+ *     {
+ *         database: "database"
+ *     }
+ */
+export interface CollectionsDatabasesRequest {
+    /** Database identifier */
+    database: string;
+}

package/dist/api/resources/databases/client/requests/DeleteDatabasesRequest.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @example
+ *     {
+ *         database: "database"
+ *     }
+ */
+export interface DeleteDatabasesRequest {
+    /** Database identifier to delete */
+    database: string;
+}

package/dist/api/resources/databases/client/requests/StatsDatabasesRequest.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @example
+ *     {
+ *         database: "database"
+ *     }
+ */
+export interface StatsDatabasesRequest {
+    /** Database identifier */
+    database: string;
+}