@forteplatforms/sdk 1.0.301 → 1.0.322

package/dist/generated/apis/ProjectsServerApi.d.ts

@@ -49,10 +49,12 @@ import { type GetContentDownloadLinkResponse } from '../models/GetContentDownloa
 import { type ImpersonationTokenResponse } from '../models/ImpersonationTokenResponse';
 import { type ListContentResponse } from '../models/ListContentResponse';
 import { type ListCustomDomainsResponse } from '../models/ListCustomDomainsResponse';
+import { type ListManagedDatabaseSlowQueriesResponse } from '../models/ListManagedDatabaseSlowQueriesResponse';
 import { type ListManagedDatabaseUsersResponse } from '../models/ListManagedDatabaseUsersResponse';
 import { type ListManagedDatabasesResponse } from '../models/ListManagedDatabasesResponse';
 import { type ListSessionsResponse } from '../models/ListSessionsResponse';
 import { type ManagedDatabaseConnection } from '../models/ManagedDatabaseConnection';
+import { type ManagedDatabaseMetricsResponse } from '../models/ManagedDatabaseMetricsResponse';
 import { type ManagedDatabaseObject } from '../models/ManagedDatabaseObject';
 import { type NotificationTemplatesResponse } from '../models/NotificationTemplatesResponse';
 import { type PaginatedResponseActionInvocationObject } from '../models/PaginatedResponseActionInvocationObject';
@@ -313,6 +315,11 @@ export interface GetManagedDatabaseRequest {
     projectId: string;
     databaseId: string;
 }
+export interface GetManagedDatabaseMetricsRequest {
+    projectId: string;
+    databaseId: string;
+    rangeHours?: number;
+}
 export interface GetNotificationTemplatesRequest {
     projectId: string;
 }
@@ -418,6 +425,12 @@ export interface ListLogLinesRequest {
     level?: string;
     nextToken?: string;
 }
+export interface ListManagedDatabaseSlowQueriesRequest {
+    projectId: string;
+    databaseId: string;
+    page?: number;
+    pageSize?: number;
+}
 export interface ListManagedDatabaseUsersRequest {
     projectId: string;
     databaseId: string;
@@ -1217,6 +1230,16 @@ export declare class ProjectsServerApi extends runtime.BaseAPI {
     /**
      */
     getManagedDatabase(requestParameters: GetManagedDatabaseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ManagedDatabaseObject>;
+    /**
+     * Creates request options for getManagedDatabaseMetrics without sending the request
+     */
+    getManagedDatabaseMetricsRequestOpts(requestParameters: GetManagedDatabaseMetricsRequest): Promise<runtime.RequestOpts>;
+    /**
+     */
+    getManagedDatabaseMetricsRaw(requestParameters: GetManagedDatabaseMetricsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ManagedDatabaseMetricsResponse>>;
+    /**
+     */
+    getManagedDatabaseMetrics(requestParameters: GetManagedDatabaseMetricsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ManagedDatabaseMetricsResponse>;
     /**
      * Creates request options for getNotificationTemplates without sending the request
      */
@@ -1417,6 +1440,16 @@ export declare class ProjectsServerApi extends runtime.BaseAPI {
     /**
      */
     listLogLines(requestParameters: ListLogLinesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedResponseLogLineObject>;
+    /**
+     * Creates request options for listManagedDatabaseSlowQueries without sending the request
+     */
+    listManagedDatabaseSlowQueriesRequestOpts(requestParameters: ListManagedDatabaseSlowQueriesRequest): Promise<runtime.RequestOpts>;
+    /**
+     */
+    listManagedDatabaseSlowQueriesRaw(requestParameters: ListManagedDatabaseSlowQueriesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ListManagedDatabaseSlowQueriesResponse>>;
+    /**
+     */
+    listManagedDatabaseSlowQueries(requestParameters: ListManagedDatabaseSlowQueriesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ListManagedDatabaseSlowQueriesResponse>;
     /**
      * Creates request options for listManagedDatabaseUsers without sending the request
      */

package/dist/generated/apis/ProjectsServerApi.js

@@ -105,10 +105,12 @@ var GetContentDownloadLinkResponse_1 = require("../models/GetContentDownloadLink
 var ImpersonationTokenResponse_1 = require("../models/ImpersonationTokenResponse");
 var ListContentResponse_1 = require("../models/ListContentResponse");
 var ListCustomDomainsResponse_1 = require("../models/ListCustomDomainsResponse");
+var ListManagedDatabaseSlowQueriesResponse_1 = require("../models/ListManagedDatabaseSlowQueriesResponse");
 var ListManagedDatabaseUsersResponse_1 = require("../models/ListManagedDatabaseUsersResponse");
 var ListManagedDatabasesResponse_1 = require("../models/ListManagedDatabasesResponse");
 var ListSessionsResponse_1 = require("../models/ListSessionsResponse");
 var ManagedDatabaseConnection_1 = require("../models/ManagedDatabaseConnection");
+var ManagedDatabaseMetricsResponse_1 = require("../models/ManagedDatabaseMetricsResponse");
 var ManagedDatabaseObject_1 = require("../models/ManagedDatabaseObject");
 var NotificationTemplatesResponse_1 = require("../models/NotificationTemplatesResponse");
 var PaginatedResponseActionInvocationObject_1 = require("../models/PaginatedResponseActionInvocationObject");
@@ -3012,6 +3014,70 @@ var ProjectsServerApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for getManagedDatabaseMetrics without sending the request
+     */
+    ProjectsServerApi.prototype.getManagedDatabaseMetricsRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling getManagedDatabaseMetrics().');
+                }
+                if (requestParameters['databaseId'] == null) {
+                    throw new runtime.RequiredError('databaseId', 'Required parameter "databaseId" was null or undefined when calling getManagedDatabaseMetrics().');
+                }
+                queryParameters = {};
+                if (requestParameters['rangeHours'] != null) {
+                    queryParameters['rangeHours'] = requestParameters['rangeHours'];
+                }
+                headerParameters = {};
+                urlPath = "/api/v1/projects/{projectId}/databases/{databaseId}/metrics";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                urlPath = urlPath.replace('{databaseId}', encodeURIComponent(String(requestParameters['databaseId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'GET',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    ProjectsServerApi.prototype.getManagedDatabaseMetricsRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getManagedDatabaseMetricsRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, ManagedDatabaseMetricsResponse_1.ManagedDatabaseMetricsResponseFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     */
+    ProjectsServerApi.prototype.getManagedDatabaseMetrics = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getManagedDatabaseMetricsRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Creates request options for getNotificationTemplates without sending the request
      */
@@ -4307,6 +4373,73 @@ var ProjectsServerApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for listManagedDatabaseSlowQueries without sending the request
+     */
+    ProjectsServerApi.prototype.listManagedDatabaseSlowQueriesRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling listManagedDatabaseSlowQueries().');
+                }
+                if (requestParameters['databaseId'] == null) {
+                    throw new runtime.RequiredError('databaseId', 'Required parameter "databaseId" was null or undefined when calling listManagedDatabaseSlowQueries().');
+                }
+                queryParameters = {};
+                if (requestParameters['page'] != null) {
+                    queryParameters['page'] = requestParameters['page'];
+                }
+                if (requestParameters['pageSize'] != null) {
+                    queryParameters['pageSize'] = requestParameters['pageSize'];
+                }
+                headerParameters = {};
+                urlPath = "/api/v1/projects/{projectId}/databases/{databaseId}/slow-queries";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                urlPath = urlPath.replace('{databaseId}', encodeURIComponent(String(requestParameters['databaseId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'GET',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    ProjectsServerApi.prototype.listManagedDatabaseSlowQueriesRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.listManagedDatabaseSlowQueriesRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, ListManagedDatabaseSlowQueriesResponse_1.ListManagedDatabaseSlowQueriesResponseFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     */
+    ProjectsServerApi.prototype.listManagedDatabaseSlowQueries = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.listManagedDatabaseSlowQueriesRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Creates request options for listManagedDatabaseUsers without sending the request
      */

package/dist/generated/models/ForteApiException.d.ts

@@ -56,7 +56,6 @@ export declare const ForteApiExceptionErrorCodeType: {
     readonly MANAGED_DATABASE_NOT_FOUND: "MANAGED_DATABASE_NOT_FOUND";
     readonly MANAGED_DATABASE_TYPE_NOT_AVAILABLE: "MANAGED_DATABASE_TYPE_NOT_AVAILABLE";
     readonly MANAGED_DATABASE_DEDICATED_TIER_REQUIRES_SUPPORT: "MANAGED_DATABASE_DEDICATED_TIER_REQUIRES_SUPPORT";
-    readonly MANAGED_DATABASE_INVALID_MEMORY: "MANAGED_DATABASE_INVALID_MEMORY";
     readonly MANAGED_DATABASE_USER_QUOTA_EXCEEDED: "MANAGED_DATABASE_USER_QUOTA_EXCEEDED";
     readonly MANAGED_DATABASE_USERNAME_TAKEN: "MANAGED_DATABASE_USERNAME_TAKEN";
     readonly MANAGED_DATABASE_USERNAME_RESERVED: "MANAGED_DATABASE_USERNAME_RESERVED";
@@ -68,6 +67,15 @@ export declare const ForteApiExceptionErrorCodeType: {
     readonly MANAGED_DATABASE_CONNECTION_ENV_VAR_CONFLICT: "MANAGED_DATABASE_CONNECTION_ENV_VAR_CONFLICT";
     readonly MANAGED_DATABASE_ENV_VAR_MAPPING_REQUIRED: "MANAGED_DATABASE_ENV_VAR_MAPPING_REQUIRED";
     readonly MANAGED_DATABASE_HAS_ACTIVE_CONNECTIONS: "MANAGED_DATABASE_HAS_ACTIVE_CONNECTIONS";
+    readonly MANAGED_DATABASE_NOT_READY: "MANAGED_DATABASE_NOT_READY";
+    readonly MANAGED_DATABASE_STORAGE_BELOW_USAGE: "MANAGED_DATABASE_STORAGE_BELOW_USAGE";
+    readonly MANAGED_DATABASE_USERNAME_TOO_LONG: "MANAGED_DATABASE_USERNAME_TOO_LONG";
+    readonly MANAGED_DATABASE_AGENT_COMMAND_FAILED: "MANAGED_DATABASE_AGENT_COMMAND_FAILED";
+    readonly MANAGED_DATABASE_CLUSTER_ALREADY_EXISTS: "MANAGED_DATABASE_CLUSTER_ALREADY_EXISTS";
+    readonly MANAGED_DATABASE_CLUSTER_DISCOVERY_FAILED: "MANAGED_DATABASE_CLUSTER_DISCOVERY_FAILED";
+    readonly MANAGED_DATABASE_CLUSTER_INSTANCE_NOT_FOUND: "MANAGED_DATABASE_CLUSTER_INSTANCE_NOT_FOUND";
+    readonly MANAGED_DATABASE_CLUSTER_PROVISIONING_IN_PROGRESS: "MANAGED_DATABASE_CLUSTER_PROVISIONING_IN_PROGRESS";
+    readonly MANAGED_DATABASE_CLUSTER_HAS_TENANTS: "MANAGED_DATABASE_CLUSTER_HAS_TENANTS";
     readonly SITE_PASSWORD_NOT_SUPPORTED: "SITE_PASSWORD_NOT_SUPPORTED";
     readonly CONFLICTING_SITE_PASSWORD_FIELDS: "CONFLICTING_SITE_PASSWORD_FIELDS";
     readonly SESSION_TOKEN_PROJECT_MISMATCH: "SESSION_TOKEN_PROJECT_MISMATCH";

package/dist/generated/models/ForteApiException.js

@@ -41,7 +41,6 @@ exports.ForteApiExceptionErrorCodeType = {
     MANAGED_DATABASE_NOT_FOUND: 'MANAGED_DATABASE_NOT_FOUND',
     MANAGED_DATABASE_TYPE_NOT_AVAILABLE: 'MANAGED_DATABASE_TYPE_NOT_AVAILABLE',
     MANAGED_DATABASE_DEDICATED_TIER_REQUIRES_SUPPORT: 'MANAGED_DATABASE_DEDICATED_TIER_REQUIRES_SUPPORT',
-    MANAGED_DATABASE_INVALID_MEMORY: 'MANAGED_DATABASE_INVALID_MEMORY',
     MANAGED_DATABASE_USER_QUOTA_EXCEEDED: 'MANAGED_DATABASE_USER_QUOTA_EXCEEDED',
     MANAGED_DATABASE_USERNAME_TAKEN: 'MANAGED_DATABASE_USERNAME_TAKEN',
     MANAGED_DATABASE_USERNAME_RESERVED: 'MANAGED_DATABASE_USERNAME_RESERVED',
@@ -53,6 +52,15 @@ exports.ForteApiExceptionErrorCodeType = {
     MANAGED_DATABASE_CONNECTION_ENV_VAR_CONFLICT: 'MANAGED_DATABASE_CONNECTION_ENV_VAR_CONFLICT',
     MANAGED_DATABASE_ENV_VAR_MAPPING_REQUIRED: 'MANAGED_DATABASE_ENV_VAR_MAPPING_REQUIRED',
     MANAGED_DATABASE_HAS_ACTIVE_CONNECTIONS: 'MANAGED_DATABASE_HAS_ACTIVE_CONNECTIONS',
+    MANAGED_DATABASE_NOT_READY: 'MANAGED_DATABASE_NOT_READY',
+    MANAGED_DATABASE_STORAGE_BELOW_USAGE: 'MANAGED_DATABASE_STORAGE_BELOW_USAGE',
+    MANAGED_DATABASE_USERNAME_TOO_LONG: 'MANAGED_DATABASE_USERNAME_TOO_LONG',
+    MANAGED_DATABASE_AGENT_COMMAND_FAILED: 'MANAGED_DATABASE_AGENT_COMMAND_FAILED',
+    MANAGED_DATABASE_CLUSTER_ALREADY_EXISTS: 'MANAGED_DATABASE_CLUSTER_ALREADY_EXISTS',
+    MANAGED_DATABASE_CLUSTER_DISCOVERY_FAILED: 'MANAGED_DATABASE_CLUSTER_DISCOVERY_FAILED',
+    MANAGED_DATABASE_CLUSTER_INSTANCE_NOT_FOUND: 'MANAGED_DATABASE_CLUSTER_INSTANCE_NOT_FOUND',
+    MANAGED_DATABASE_CLUSTER_PROVISIONING_IN_PROGRESS: 'MANAGED_DATABASE_CLUSTER_PROVISIONING_IN_PROGRESS',
+    MANAGED_DATABASE_CLUSTER_HAS_TENANTS: 'MANAGED_DATABASE_CLUSTER_HAS_TENANTS',
     SITE_PASSWORD_NOT_SUPPORTED: 'SITE_PASSWORD_NOT_SUPPORTED',
     CONFLICTING_SITE_PASSWORD_FIELDS: 'CONFLICTING_SITE_PASSWORD_FIELDS',
     SESSION_TOKEN_PROJECT_MISMATCH: 'SESSION_TOKEN_PROJECT_MISMATCH',

package/dist/generated/models/ListManagedDatabaseSlowQueriesResponse.d.ts

@@ -0,0 +1,39 @@
+/**
+ * OpenAPI definition
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: v0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { ManagedDatabaseSlowQuery } from './ManagedDatabaseSlowQuery';
+/**
+ *
+ * @export
+ * @interface ListManagedDatabaseSlowQueriesResponse
+ */
+export interface ListManagedDatabaseSlowQueriesResponse {
+    /**
+     *
+     * @type {Array<ManagedDatabaseSlowQuery>}
+     * @memberof ListManagedDatabaseSlowQueriesResponse
+     */
+    items: Array<ManagedDatabaseSlowQuery>;
+    /**
+     *
+     * @type {string}
+     * @memberof ListManagedDatabaseSlowQueriesResponse
+     */
+    nextPageToken?: string;
+}
+/**
+ * Check if a given object implements the ListManagedDatabaseSlowQueriesResponse interface.
+ */
+export declare function instanceOfListManagedDatabaseSlowQueriesResponse(value: object): value is ListManagedDatabaseSlowQueriesResponse;
+export declare function ListManagedDatabaseSlowQueriesResponseFromJSON(json: any): ListManagedDatabaseSlowQueriesResponse;
+export declare function ListManagedDatabaseSlowQueriesResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): ListManagedDatabaseSlowQueriesResponse;
+export declare function ListManagedDatabaseSlowQueriesResponseToJSON(json: any): ListManagedDatabaseSlowQueriesResponse;
+export declare function ListManagedDatabaseSlowQueriesResponseToJSONTyped(value?: ListManagedDatabaseSlowQueriesResponse | null, ignoreDiscriminator?: boolean): any;

package/dist/generated/models/ListManagedDatabaseSlowQueriesResponse.js

@@ -0,0 +1,54 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI definition
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: v0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instanceOfListManagedDatabaseSlowQueriesResponse = instanceOfListManagedDatabaseSlowQueriesResponse;
+exports.ListManagedDatabaseSlowQueriesResponseFromJSON = ListManagedDatabaseSlowQueriesResponseFromJSON;
+exports.ListManagedDatabaseSlowQueriesResponseFromJSONTyped = ListManagedDatabaseSlowQueriesResponseFromJSONTyped;
+exports.ListManagedDatabaseSlowQueriesResponseToJSON = ListManagedDatabaseSlowQueriesResponseToJSON;
+exports.ListManagedDatabaseSlowQueriesResponseToJSONTyped = ListManagedDatabaseSlowQueriesResponseToJSONTyped;
+var ManagedDatabaseSlowQuery_1 = require("./ManagedDatabaseSlowQuery");
+/**
+ * Check if a given object implements the ListManagedDatabaseSlowQueriesResponse interface.
+ */
+function instanceOfListManagedDatabaseSlowQueriesResponse(value) {
+    if (!('items' in value) || value['items'] === undefined)
+        return false;
+    return true;
+}
+function ListManagedDatabaseSlowQueriesResponseFromJSON(json) {
+    return ListManagedDatabaseSlowQueriesResponseFromJSONTyped(json, false);
+}
+function ListManagedDatabaseSlowQueriesResponseFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'items': (json['items'].map(ManagedDatabaseSlowQuery_1.ManagedDatabaseSlowQueryFromJSON)),
+        'nextPageToken': json['nextPageToken'] == null ? undefined : json['nextPageToken'],
+    };
+}
+function ListManagedDatabaseSlowQueriesResponseToJSON(json) {
+    return ListManagedDatabaseSlowQueriesResponseToJSONTyped(json, false);
+}
+function ListManagedDatabaseSlowQueriesResponseToJSONTyped(value, ignoreDiscriminator) {
+    if (ignoreDiscriminator === void 0) { ignoreDiscriminator = false; }
+    if (value == null) {
+        return value;
+    }
+    return {
+        'items': (value['items'].map(ManagedDatabaseSlowQuery_1.ManagedDatabaseSlowQueryToJSON)),
+        'nextPageToken': value['nextPageToken'],
+    };
+}

package/dist/generated/models/ManagedDatabaseMetricPoint.d.ts

@@ -0,0 +1,176 @@
+/**
+ * OpenAPI definition
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: v0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface ManagedDatabaseMetricPoint
+ */
+export interface ManagedDatabaseMetricPoint {
+    /**
+     *
+     * @type {Date}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    timestamp: Date;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    activeTimeMs?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    xactCommit?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    xactRollback?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    blksHit?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    blksRead?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    tupReturned?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    tupFetched?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    tupInserted?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    tupUpdated?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    tupDeleted?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    tempFiles?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    tempBytes?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    deadlocks?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    stmtTotalExecMs?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    stmtCalls?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    stmtWalBytes?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    stmtTempBlks?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    queryCount?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    avgQueryTimeMicros?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    clientConnections?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    serverConnections?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    clWaiting?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    logicalSizeBytes?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseMetricPoint
+     */
+    physicalSizeBytes?: number;
+}
+/**
+ * Check if a given object implements the ManagedDatabaseMetricPoint interface.
+ */
+export declare function instanceOfManagedDatabaseMetricPoint(value: object): value is ManagedDatabaseMetricPoint;
+export declare function ManagedDatabaseMetricPointFromJSON(json: any): ManagedDatabaseMetricPoint;
+export declare function ManagedDatabaseMetricPointFromJSONTyped(json: any, ignoreDiscriminator: boolean): ManagedDatabaseMetricPoint;
+export declare function ManagedDatabaseMetricPointToJSON(json: any): ManagedDatabaseMetricPoint;
+export declare function ManagedDatabaseMetricPointToJSONTyped(value?: ManagedDatabaseMetricPoint | null, ignoreDiscriminator?: boolean): any;

package/dist/generated/models/ManagedDatabaseMetricPoint.js

@@ -0,0 +1,99 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI definition
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: v0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instanceOfManagedDatabaseMetricPoint = instanceOfManagedDatabaseMetricPoint;
+exports.ManagedDatabaseMetricPointFromJSON = ManagedDatabaseMetricPointFromJSON;
+exports.ManagedDatabaseMetricPointFromJSONTyped = ManagedDatabaseMetricPointFromJSONTyped;
+exports.ManagedDatabaseMetricPointToJSON = ManagedDatabaseMetricPointToJSON;
+exports.ManagedDatabaseMetricPointToJSONTyped = ManagedDatabaseMetricPointToJSONTyped;
+/**
+ * Check if a given object implements the ManagedDatabaseMetricPoint interface.
+ */
+function instanceOfManagedDatabaseMetricPoint(value) {
+    if (!('timestamp' in value) || value['timestamp'] === undefined)
+        return false;
+    return true;
+}
+function ManagedDatabaseMetricPointFromJSON(json) {
+    return ManagedDatabaseMetricPointFromJSONTyped(json, false);
+}
+function ManagedDatabaseMetricPointFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'timestamp': (new Date(json['timestamp'])),
+        'activeTimeMs': json['activeTimeMs'] == null ? undefined : json['activeTimeMs'],
+        'xactCommit': json['xactCommit'] == null ? undefined : json['xactCommit'],
+        'xactRollback': json['xactRollback'] == null ? undefined : json['xactRollback'],
+        'blksHit': json['blksHit'] == null ? undefined : json['blksHit'],
+        'blksRead': json['blksRead'] == null ? undefined : json['blksRead'],
+        'tupReturned': json['tupReturned'] == null ? undefined : json['tupReturned'],
+        'tupFetched': json['tupFetched'] == null ? undefined : json['tupFetched'],
+        'tupInserted': json['tupInserted'] == null ? undefined : json['tupInserted'],
+        'tupUpdated': json['tupUpdated'] == null ? undefined : json['tupUpdated'],
+        'tupDeleted': json['tupDeleted'] == null ? undefined : json['tupDeleted'],
+        'tempFiles': json['tempFiles'] == null ? undefined : json['tempFiles'],
+        'tempBytes': json['tempBytes'] == null ? undefined : json['tempBytes'],
+        'deadlocks': json['deadlocks'] == null ? undefined : json['deadlocks'],
+        'stmtTotalExecMs': json['stmtTotalExecMs'] == null ? undefined : json['stmtTotalExecMs'],
+        'stmtCalls': json['stmtCalls'] == null ? undefined : json['stmtCalls'],
+        'stmtWalBytes': json['stmtWalBytes'] == null ? undefined : json['stmtWalBytes'],
+        'stmtTempBlks': json['stmtTempBlks'] == null ? undefined : json['stmtTempBlks'],
+        'queryCount': json['queryCount'] == null ? undefined : json['queryCount'],
+        'avgQueryTimeMicros': json['avgQueryTimeMicros'] == null ? undefined : json['avgQueryTimeMicros'],
+        'clientConnections': json['clientConnections'] == null ? undefined : json['clientConnections'],
+        'serverConnections': json['serverConnections'] == null ? undefined : json['serverConnections'],
+        'clWaiting': json['clWaiting'] == null ? undefined : json['clWaiting'],
+        'logicalSizeBytes': json['logicalSizeBytes'] == null ? undefined : json['logicalSizeBytes'],
+        'physicalSizeBytes': json['physicalSizeBytes'] == null ? undefined : json['physicalSizeBytes'],
+    };
+}
+function ManagedDatabaseMetricPointToJSON(json) {
+    return ManagedDatabaseMetricPointToJSONTyped(json, false);
+}
+function ManagedDatabaseMetricPointToJSONTyped(value, ignoreDiscriminator) {
+    if (ignoreDiscriminator === void 0) { ignoreDiscriminator = false; }
+    if (value == null) {
+        return value;
+    }
+    return {
+        'timestamp': value['timestamp'].toISOString(),
+        'activeTimeMs': value['activeTimeMs'],
+        'xactCommit': value['xactCommit'],
+        'xactRollback': value['xactRollback'],
+        'blksHit': value['blksHit'],
+        'blksRead': value['blksRead'],
+        'tupReturned': value['tupReturned'],
+        'tupFetched': value['tupFetched'],
+        'tupInserted': value['tupInserted'],
+        'tupUpdated': value['tupUpdated'],
+        'tupDeleted': value['tupDeleted'],
+        'tempFiles': value['tempFiles'],
+        'tempBytes': value['tempBytes'],
+        'deadlocks': value['deadlocks'],
+        'stmtTotalExecMs': value['stmtTotalExecMs'],
+        'stmtCalls': value['stmtCalls'],
+        'stmtWalBytes': value['stmtWalBytes'],
+        'stmtTempBlks': value['stmtTempBlks'],
+        'queryCount': value['queryCount'],
+        'avgQueryTimeMicros': value['avgQueryTimeMicros'],
+        'clientConnections': value['clientConnections'],
+        'serverConnections': value['serverConnections'],
+        'clWaiting': value['clWaiting'],
+        'logicalSizeBytes': value['logicalSizeBytes'],
+        'physicalSizeBytes': value['physicalSizeBytes'],
+    };
+}

package/dist/generated/models/ManagedDatabaseMetricsResponse.d.ts

@@ -0,0 +1,40 @@
+/**
+ * OpenAPI definition
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: v0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { ManagedDatabaseMetricPoint } from './ManagedDatabaseMetricPoint';
+import type { ManagedDatabaseUsage } from './ManagedDatabaseUsage';
+/**
+ *
+ * @export
+ * @interface ManagedDatabaseMetricsResponse
+ */
+export interface ManagedDatabaseMetricsResponse {
+    /**
+     *
+     * @type {Array<ManagedDatabaseMetricPoint>}
+     * @memberof ManagedDatabaseMetricsResponse
+     */
+    points: Array<ManagedDatabaseMetricPoint>;
+    /**
+     *
+     * @type {ManagedDatabaseUsage}
+     * @memberof ManagedDatabaseMetricsResponse
+     */
+    usage: ManagedDatabaseUsage;
+}
+/**
+ * Check if a given object implements the ManagedDatabaseMetricsResponse interface.
+ */
+export declare function instanceOfManagedDatabaseMetricsResponse(value: object): value is ManagedDatabaseMetricsResponse;
+export declare function ManagedDatabaseMetricsResponseFromJSON(json: any): ManagedDatabaseMetricsResponse;
+export declare function ManagedDatabaseMetricsResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): ManagedDatabaseMetricsResponse;
+export declare function ManagedDatabaseMetricsResponseToJSON(json: any): ManagedDatabaseMetricsResponse;
+export declare function ManagedDatabaseMetricsResponseToJSONTyped(value?: ManagedDatabaseMetricsResponse | null, ignoreDiscriminator?: boolean): any;

package/dist/generated/models/ManagedDatabaseMetricsResponse.js

@@ -0,0 +1,57 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI definition
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: v0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instanceOfManagedDatabaseMetricsResponse = instanceOfManagedDatabaseMetricsResponse;
+exports.ManagedDatabaseMetricsResponseFromJSON = ManagedDatabaseMetricsResponseFromJSON;
+exports.ManagedDatabaseMetricsResponseFromJSONTyped = ManagedDatabaseMetricsResponseFromJSONTyped;
+exports.ManagedDatabaseMetricsResponseToJSON = ManagedDatabaseMetricsResponseToJSON;
+exports.ManagedDatabaseMetricsResponseToJSONTyped = ManagedDatabaseMetricsResponseToJSONTyped;
+var ManagedDatabaseMetricPoint_1 = require("./ManagedDatabaseMetricPoint");
+var ManagedDatabaseUsage_1 = require("./ManagedDatabaseUsage");
+/**
+ * Check if a given object implements the ManagedDatabaseMetricsResponse interface.
+ */
+function instanceOfManagedDatabaseMetricsResponse(value) {
+    if (!('points' in value) || value['points'] === undefined)
+        return false;
+    if (!('usage' in value) || value['usage'] === undefined)
+        return false;
+    return true;
+}
+function ManagedDatabaseMetricsResponseFromJSON(json) {
+    return ManagedDatabaseMetricsResponseFromJSONTyped(json, false);
+}
+function ManagedDatabaseMetricsResponseFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'points': (json['points'].map(ManagedDatabaseMetricPoint_1.ManagedDatabaseMetricPointFromJSON)),
+        'usage': (0, ManagedDatabaseUsage_1.ManagedDatabaseUsageFromJSON)(json['usage']),
+    };
+}
+function ManagedDatabaseMetricsResponseToJSON(json) {
+    return ManagedDatabaseMetricsResponseToJSONTyped(json, false);
+}
+function ManagedDatabaseMetricsResponseToJSONTyped(value, ignoreDiscriminator) {
+    if (ignoreDiscriminator === void 0) { ignoreDiscriminator = false; }
+    if (value == null) {
+        return value;
+    }
+    return {
+        'points': (value['points'].map(ManagedDatabaseMetricPoint_1.ManagedDatabaseMetricPointToJSON)),
+        'usage': (0, ManagedDatabaseUsage_1.ManagedDatabaseUsageToJSON)(value['usage']),
+    };
+}

package/dist/generated/models/ManagedDatabaseObject.d.ts

@@ -45,13 +45,13 @@ export interface ManagedDatabaseObject {
      * @type {string}
      * @memberof ManagedDatabaseObject
      */
-    cpu: string;
+    cpu?: string;
     /**
      *
      * @type {number}
      * @memberof ManagedDatabaseObject
      */
-    memoryGb: number;
+    memoryGb?: number;
     /**
      *
      * @type {number}
@@ -100,6 +100,36 @@ export interface ManagedDatabaseObject {
      * @memberof ManagedDatabaseObject
      */
     databaseName?: string;
+    /**
+     *
+     * @type {boolean}
+     * @memberof ManagedDatabaseObject
+     */
+    readOnly?: boolean;
+    /**
+     *
+     * @type {Date}
+     * @memberof ManagedDatabaseObject
+     */
+    cleanupUnlockExpiresAt?: Date;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseObject
+     */
+    usageBytes?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseObject
+     */
+    physicalUsageBytes?: number;
+    /**
+     *
+     * @type {Date}
+     * @memberof ManagedDatabaseObject
+     */
+    usageUpdatedAt?: Date;
 }
 /**
  * @export
@@ -124,6 +154,8 @@ export declare const ManagedDatabaseObjectStatusType: {
     readonly CREATING: "CREATING";
     readonly ACTIVE: "ACTIVE";
     readonly UPDATING: "UPDATING";
+    readonly READ_ONLY: "READ_ONLY";
+    readonly SUSPENDED: "SUSPENDED";
     readonly DELETING: "DELETING";
     readonly FAILED: "FAILED";
 };

package/dist/generated/models/ManagedDatabaseObject.js

@@ -41,6 +41,8 @@ exports.ManagedDatabaseObjectStatusType = {
     CREATING: 'CREATING',
     ACTIVE: 'ACTIVE',
     UPDATING: 'UPDATING',
+    READ_ONLY: 'READ_ONLY',
+    SUSPENDED: 'SUSPENDED',
     DELETING: 'DELETING',
     FAILED: 'FAILED'
 };
@@ -54,10 +56,6 @@ function instanceOfManagedDatabaseObject(value) {
         return false;
     if (!('tier' in value) || value['tier'] === undefined)
         return false;
-    if (!('cpu' in value) || value['cpu'] === undefined)
-        return false;
-    if (!('memoryGb' in value) || value['memoryGb'] === undefined)
-        return false;
     if (!('storageGb' in value) || value['storageGb'] === undefined)
         return false;
     if (!('status' in value) || value['status'] === undefined)
@@ -80,8 +78,8 @@ function ManagedDatabaseObjectFromJSONTyped(json, ignoreDiscriminator) {
         'managedDatabaseName': json['managedDatabaseName'],
         'type': json['type'],
         'tier': json['tier'],
-        'cpu': json['cpu'],
-        'memoryGb': json['memoryGb'],
+        'cpu': json['cpu'] == null ? undefined : json['cpu'],
+        'memoryGb': json['memoryGb'] == null ? undefined : json['memoryGb'],
         'storageGb': json['storageGb'],
         'status': json['status'],
         'connections': (json['connections'].map(ManagedDatabaseConnection_1.ManagedDatabaseConnectionFromJSON)),
@@ -90,6 +88,11 @@ function ManagedDatabaseObjectFromJSONTyped(json, ignoreDiscriminator) {
         'host': json['host'] == null ? undefined : json['host'],
         'port': json['port'] == null ? undefined : json['port'],
         'databaseName': json['databaseName'] == null ? undefined : json['databaseName'],
+        'readOnly': json['readOnly'] == null ? undefined : json['readOnly'],
+        'cleanupUnlockExpiresAt': json['cleanupUnlockExpiresAt'] == null ? undefined : (new Date(json['cleanupUnlockExpiresAt'])),
+        'usageBytes': json['usageBytes'] == null ? undefined : json['usageBytes'],
+        'physicalUsageBytes': json['physicalUsageBytes'] == null ? undefined : json['physicalUsageBytes'],
+        'usageUpdatedAt': json['usageUpdatedAt'] == null ? undefined : (new Date(json['usageUpdatedAt'])),
     };
 }
 function ManagedDatabaseObjectToJSON(json) {
@@ -115,5 +118,10 @@ function ManagedDatabaseObjectToJSONTyped(value, ignoreDiscriminator) {
         'host': value['host'],
         'port': value['port'],
         'databaseName': value['databaseName'],
+        'readOnly': value['readOnly'],
+        'cleanupUnlockExpiresAt': value['cleanupUnlockExpiresAt'] == null ? value['cleanupUnlockExpiresAt'] : value['cleanupUnlockExpiresAt'].toISOString(),
+        'usageBytes': value['usageBytes'],
+        'physicalUsageBytes': value['physicalUsageBytes'],
+        'usageUpdatedAt': value['usageUpdatedAt'] == null ? value['usageUpdatedAt'] : value['usageUpdatedAt'].toISOString(),
     };
 }

package/dist/generated/models/ManagedDatabaseSlowQuery.d.ts

@@ -0,0 +1,71 @@
+/**
+ * OpenAPI definition
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: v0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface ManagedDatabaseSlowQuery
+ */
+export interface ManagedDatabaseSlowQuery {
+    /**
+     *
+     * @type {string}
+     * @memberof ManagedDatabaseSlowQuery
+     */
+    slowQueryId: string;
+    /**
+     *
+     * @type {Date}
+     * @memberof ManagedDatabaseSlowQuery
+     */
+    timestamp: Date;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseSlowQuery
+     */
+    durationMs?: number;
+    /**
+     *
+     * @type {ManagedDatabaseSlowQueryKindType}
+     * @memberof ManagedDatabaseSlowQuery
+     */
+    kind: ManagedDatabaseSlowQueryKindType;
+    /**
+     *
+     * @type {string}
+     * @memberof ManagedDatabaseSlowQuery
+     */
+    queryText?: string;
+    /**
+     *
+     * @type {string}
+     * @memberof ManagedDatabaseSlowQuery
+     */
+    userName?: string;
+}
+/**
+ * @export
+ */
+export declare const ManagedDatabaseSlowQueryKindType: {
+    readonly SLOW: "SLOW";
+    readonly TEMP_FILE: "TEMP_FILE";
+    readonly LOCK_WAIT: "LOCK_WAIT";
+};
+export type ManagedDatabaseSlowQueryKindType = typeof ManagedDatabaseSlowQueryKindType[keyof typeof ManagedDatabaseSlowQueryKindType];
+/**
+ * Check if a given object implements the ManagedDatabaseSlowQuery interface.
+ */
+export declare function instanceOfManagedDatabaseSlowQuery(value: object): value is ManagedDatabaseSlowQuery;
+export declare function ManagedDatabaseSlowQueryFromJSON(json: any): ManagedDatabaseSlowQuery;
+export declare function ManagedDatabaseSlowQueryFromJSONTyped(json: any, ignoreDiscriminator: boolean): ManagedDatabaseSlowQuery;
+export declare function ManagedDatabaseSlowQueryToJSON(json: any): ManagedDatabaseSlowQuery;
+export declare function ManagedDatabaseSlowQueryToJSONTyped(value?: ManagedDatabaseSlowQuery | null, ignoreDiscriminator?: boolean): any;

package/dist/generated/models/ManagedDatabaseSlowQuery.js

@@ -0,0 +1,74 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI definition
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: v0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManagedDatabaseSlowQueryKindType = void 0;
+exports.instanceOfManagedDatabaseSlowQuery = instanceOfManagedDatabaseSlowQuery;
+exports.ManagedDatabaseSlowQueryFromJSON = ManagedDatabaseSlowQueryFromJSON;
+exports.ManagedDatabaseSlowQueryFromJSONTyped = ManagedDatabaseSlowQueryFromJSONTyped;
+exports.ManagedDatabaseSlowQueryToJSON = ManagedDatabaseSlowQueryToJSON;
+exports.ManagedDatabaseSlowQueryToJSONTyped = ManagedDatabaseSlowQueryToJSONTyped;
+/**
+ * @export
+ */
+exports.ManagedDatabaseSlowQueryKindType = {
+    SLOW: 'SLOW',
+    TEMP_FILE: 'TEMP_FILE',
+    LOCK_WAIT: 'LOCK_WAIT'
+};
+/**
+ * Check if a given object implements the ManagedDatabaseSlowQuery interface.
+ */
+function instanceOfManagedDatabaseSlowQuery(value) {
+    if (!('slowQueryId' in value) || value['slowQueryId'] === undefined)
+        return false;
+    if (!('timestamp' in value) || value['timestamp'] === undefined)
+        return false;
+    if (!('kind' in value) || value['kind'] === undefined)
+        return false;
+    return true;
+}
+function ManagedDatabaseSlowQueryFromJSON(json) {
+    return ManagedDatabaseSlowQueryFromJSONTyped(json, false);
+}
+function ManagedDatabaseSlowQueryFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'slowQueryId': json['slowQueryId'],
+        'timestamp': (new Date(json['timestamp'])),
+        'durationMs': json['durationMs'] == null ? undefined : json['durationMs'],
+        'kind': json['kind'],
+        'queryText': json['queryText'] == null ? undefined : json['queryText'],
+        'userName': json['userName'] == null ? undefined : json['userName'],
+    };
+}
+function ManagedDatabaseSlowQueryToJSON(json) {
+    return ManagedDatabaseSlowQueryToJSONTyped(json, false);
+}
+function ManagedDatabaseSlowQueryToJSONTyped(value, ignoreDiscriminator) {
+    if (ignoreDiscriminator === void 0) { ignoreDiscriminator = false; }
+    if (value == null) {
+        return value;
+    }
+    return {
+        'slowQueryId': value['slowQueryId'],
+        'timestamp': value['timestamp'].toISOString(),
+        'durationMs': value['durationMs'],
+        'kind': value['kind'],
+        'queryText': value['queryText'],
+        'userName': value['userName'],
+    };
+}

package/dist/generated/models/ManagedDatabaseUsage.d.ts

@@ -0,0 +1,56 @@
+/**
+ * OpenAPI definition
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: v0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface ManagedDatabaseUsage
+ */
+export interface ManagedDatabaseUsage {
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseUsage
+     */
+    usageBytes?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseUsage
+     */
+    physicalUsageBytes?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof ManagedDatabaseUsage
+     */
+    storageGb: number;
+    /**
+     *
+     * @type {Date}
+     * @memberof ManagedDatabaseUsage
+     */
+    usageUpdatedAt?: Date;
+    /**
+     *
+     * @type {boolean}
+     * @memberof ManagedDatabaseUsage
+     */
+    readOnly: boolean;
+}
+/**
+ * Check if a given object implements the ManagedDatabaseUsage interface.
+ */
+export declare function instanceOfManagedDatabaseUsage(value: object): value is ManagedDatabaseUsage;
+export declare function ManagedDatabaseUsageFromJSON(json: any): ManagedDatabaseUsage;
+export declare function ManagedDatabaseUsageFromJSONTyped(json: any, ignoreDiscriminator: boolean): ManagedDatabaseUsage;
+export declare function ManagedDatabaseUsageToJSON(json: any): ManagedDatabaseUsage;
+export declare function ManagedDatabaseUsageToJSONTyped(value?: ManagedDatabaseUsage | null, ignoreDiscriminator?: boolean): any;

package/dist/generated/models/ManagedDatabaseUsage.js

@@ -0,0 +1,61 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI definition
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: v0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instanceOfManagedDatabaseUsage = instanceOfManagedDatabaseUsage;
+exports.ManagedDatabaseUsageFromJSON = ManagedDatabaseUsageFromJSON;
+exports.ManagedDatabaseUsageFromJSONTyped = ManagedDatabaseUsageFromJSONTyped;
+exports.ManagedDatabaseUsageToJSON = ManagedDatabaseUsageToJSON;
+exports.ManagedDatabaseUsageToJSONTyped = ManagedDatabaseUsageToJSONTyped;
+/**
+ * Check if a given object implements the ManagedDatabaseUsage interface.
+ */
+function instanceOfManagedDatabaseUsage(value) {
+    if (!('storageGb' in value) || value['storageGb'] === undefined)
+        return false;
+    if (!('readOnly' in value) || value['readOnly'] === undefined)
+        return false;
+    return true;
+}
+function ManagedDatabaseUsageFromJSON(json) {
+    return ManagedDatabaseUsageFromJSONTyped(json, false);
+}
+function ManagedDatabaseUsageFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'usageBytes': json['usageBytes'] == null ? undefined : json['usageBytes'],
+        'physicalUsageBytes': json['physicalUsageBytes'] == null ? undefined : json['physicalUsageBytes'],
+        'storageGb': json['storageGb'],
+        'usageUpdatedAt': json['usageUpdatedAt'] == null ? undefined : (new Date(json['usageUpdatedAt'])),
+        'readOnly': json['readOnly'],
+    };
+}
+function ManagedDatabaseUsageToJSON(json) {
+    return ManagedDatabaseUsageToJSONTyped(json, false);
+}
+function ManagedDatabaseUsageToJSONTyped(value, ignoreDiscriminator) {
+    if (ignoreDiscriminator === void 0) { ignoreDiscriminator = false; }
+    if (value == null) {
+        return value;
+    }
+    return {
+        'usageBytes': value['usageBytes'],
+        'physicalUsageBytes': value['physicalUsageBytes'],
+        'storageGb': value['storageGb'],
+        'usageUpdatedAt': value['usageUpdatedAt'] == null ? value['usageUpdatedAt'] : value['usageUpdatedAt'].toISOString(),
+        'readOnly': value['readOnly'],
+    };
+}

package/dist/generated/models/index.d.ts

@@ -72,6 +72,7 @@ export * from './LatencyPercentileSeries';
 export * from './LatencyStats';
 export * from './ListContentResponse';
 export * from './ListCustomDomainsResponse';
+export * from './ListManagedDatabaseSlowQueriesResponse';
 export * from './ListManagedDatabaseUsersResponse';
 export * from './ListManagedDatabasesResponse';
 export * from './ListMfaMethodsResponse';
@@ -82,7 +83,11 @@ export * from './LoginHistoryEntry';
 export * from './LoginUserResponse';
 export * from './ManagedDatabaseConnection';
 export * from './ManagedDatabaseEnvVarMappings';
+export * from './ManagedDatabaseMetricPoint';
+export * from './ManagedDatabaseMetricsResponse';
 export * from './ManagedDatabaseObject';
+export * from './ManagedDatabaseSlowQuery';
+export * from './ManagedDatabaseUsage';
 export * from './ManagedDatabaseUser';
 export * from './MfaChallengeRequest';
 export * from './MfaChallengeResponse';

package/dist/generated/models/index.js

@@ -90,6 +90,7 @@ __exportStar(require("./LatencyPercentileSeries"), exports);
 __exportStar(require("./LatencyStats"), exports);
 __exportStar(require("./ListContentResponse"), exports);
 __exportStar(require("./ListCustomDomainsResponse"), exports);
+__exportStar(require("./ListManagedDatabaseSlowQueriesResponse"), exports);
 __exportStar(require("./ListManagedDatabaseUsersResponse"), exports);
 __exportStar(require("./ListManagedDatabasesResponse"), exports);
 __exportStar(require("./ListMfaMethodsResponse"), exports);
@@ -100,7 +101,11 @@ __exportStar(require("./LoginHistoryEntry"), exports);
 __exportStar(require("./LoginUserResponse"), exports);
 __exportStar(require("./ManagedDatabaseConnection"), exports);
 __exportStar(require("./ManagedDatabaseEnvVarMappings"), exports);
+__exportStar(require("./ManagedDatabaseMetricPoint"), exports);
+__exportStar(require("./ManagedDatabaseMetricsResponse"), exports);
 __exportStar(require("./ManagedDatabaseObject"), exports);
+__exportStar(require("./ManagedDatabaseSlowQuery"), exports);
+__exportStar(require("./ManagedDatabaseUsage"), exports);
 __exportStar(require("./ManagedDatabaseUser"), exports);
 __exportStar(require("./MfaChallengeRequest"), exports);
 __exportStar(require("./MfaChallengeResponse"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forteplatforms/sdk",
-  "version": "1.0.301",
+  "version": "1.0.322",
   "description": "Official TypeScript SDK for Forte Platforms",
   "author": "Forte Platforms <support@forteplatforms.com>",
   "repository": {