@distilled.cloud/stackit 0.0.0-stage → 1.0.0-rc.14

package/lib/services/mongodb_flex.d.ts

@@ -0,0 +1,826 @@
+import * as API from "@distilled.cloud/core/api";
+import * as S from "@distilled.cloud/core/schema";
+import * as Redacted from "effect/Redacted";
+import { type StackitOpError, type StackitOpContext } from "../protocol.ts";
+export type { StackitOpError, StackitOpContext };
+declare const BadRequest_base: S.Class<BadRequest, S.TaggedStruct<"BadRequest", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class BadRequest extends /*@__PURE__*/ BadRequest_base {
+}
+declare const Conflict_base: S.Class<Conflict, S.TaggedStruct<"Conflict", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
+export declare class Conflict extends /*@__PURE__*/ Conflict_base {
+}
+declare const NotFound_base: S.Class<NotFound, S.TaggedStruct<"NotFound", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class NotFound extends /*@__PURE__*/ NotFound_base {
+}
+export type CloneInstanceRequestRegion = "eu01" | "eu02";
+export declare const CloneInstanceRequestRegion: any;
+export interface CloneInstanceRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: CloneInstanceRequestRegion | (string & {});
+    /** instance id */
+    instanceId: string;
+    timestamp?: string;
+}
+export declare const CloneInstanceRequest: S.Schema<CloneInstanceRequest>;
+export interface CloneInstanceResponse {
+    instanceId?: string;
+}
+export declare const CloneInstanceResponse: S.Schema<CloneInstanceResponse>;
+export type CreateInstanceRequestRegion = "eu01" | "eu02";
+export declare const CreateInstanceRequestRegion: any;
+export type ACLItemsList = Array<string>;
+export declare const ACLItemsList: S.Schema<ACLItemsList>;
+export interface ACL {
+    items?: ACLItemsList;
+}
+export declare const ACL: S.Schema<ACL>;
+/** Labels field is not certain/clear */
+export type CreateInstanceRequestLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateInstanceRequestLabelsMap: S.Schema<CreateInstanceRequestLabelsMap>;
+export type CreateInstanceRequestOptionsMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateInstanceRequestOptionsMap: S.Schema<CreateInstanceRequestOptionsMap>;
+export interface Storage {
+    class?: string;
+    size?: number;
+}
+export declare const Storage: S.Schema<Storage>;
+export interface CreateInstanceRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: CreateInstanceRequestRegion | (string & {});
+    /** ACL is the Access Control List defining the IP ranges allowed to connect to the database */
+    acl: ACL;
+    backupSchedule: string;
+    flavorId: string;
+    /** Labels field is not certain/clear */
+    labels?: CreateInstanceRequestLabelsMap;
+    name: string;
+    options: CreateInstanceRequestOptionsMap;
+    replicas: number;
+    storage: Storage;
+    version: string;
+}
+export declare const CreateInstanceRequest: S.Schema<CreateInstanceRequest>;
+export interface CreateInstanceResponse {
+    id?: string;
+}
+export declare const CreateInstanceResponse: S.Schema<CreateInstanceResponse>;
+export type CreateUserRequestRegion = "eu01" | "eu02";
+export declare const CreateUserRequestRegion: any;
+/** The roles defined for a user. Currently only one role in the list is supported, therefore only the first role from this list is used. The *roles* attribute can contain the following values: 'read', 'readWrite', 'readAnyDatabase', 'readWriteAnyDatabase', 'stackitAdmin'. **The 'readAnyDatabase', 'readWriteAnyDatabase' and 'stackitAdmin' roles will always be created in the admin database.** */
+export type CreateUserRequestRolesList = Array<string>;
+export declare const CreateUserRequestRolesList: S.Schema<CreateUserRequestRolesList>;
+export interface CreateUserRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: CreateUserRequestRegion | (string & {});
+    /** instance id */
+    instanceId: string;
+    database: string;
+    /** The roles defined for a user. Currently only one role in the list is supported, therefore only the first role from this list is used. The *roles* attribute can contain the following values: 'read', 'readWrite', 'readAnyDatabase', 'readWriteAnyDatabase', 'stackitAdmin'. **The 'readAnyDatabase', 'readWriteAnyDatabase' and 'stackitAdmin' roles will always be created in the admin database.** */
+    roles: CreateUserRequestRolesList;
+    username?: string;
+}
+export declare const CreateUserRequest: S.Schema<CreateUserRequest>;
+/** The roles defined for a user. Currently only one role in the list is supported, therefore only the first role from this list is used. The *roles* attribute can contain the following values: 'read', 'readWrite', 'readAnyDatabase', 'readWriteAnyDatabase', 'stackitAdmin'. **The 'readAnyDatabase', 'readWriteAnyDatabase' and 'stackitAdmin' roles will always be created in the admin database.** */
+export type UserRolesList = Array<string>;
+export declare const UserRolesList: S.Schema<UserRolesList>;
+export interface User {
+    database?: string;
+    host?: string;
+    id?: string;
+    password?: string | Redacted.Redacted<string>;
+    port?: number;
+    /** The roles defined for a user. Currently only one role in the list is supported, therefore only the first role from this list is used. The *roles* attribute can contain the following values: 'read', 'readWrite', 'readAnyDatabase', 'readWriteAnyDatabase', 'stackitAdmin'. **The 'readAnyDatabase', 'readWriteAnyDatabase' and 'stackitAdmin' roles will always be created in the admin database.** */
+    roles?: UserRolesList;
+    uri?: string;
+    username?: string;
+}
+export declare const User: S.Schema<User>;
+export interface CreateUserResponse {
+    item?: User;
+}
+export declare const CreateUserResponse: S.Schema<CreateUserResponse>;
+export type DeleteInstanceRequestRegion = "eu01" | "eu02";
+export declare const DeleteInstanceRequestRegion: any;
+export interface DeleteInstanceRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: DeleteInstanceRequestRegion | (string & {});
+    /** instance id */
+    instanceId: string;
+}
+export declare const DeleteInstanceRequest: S.Schema<DeleteInstanceRequest>;
+export interface DeleteInstanceResponse {
+}
+export declare const DeleteInstanceResponse: S.Schema<DeleteInstanceResponse>;
+export type DeleteUserRequestRegion = "eu01" | "eu02";
+export declare const DeleteUserRequestRegion: any;
+export interface DeleteUserRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: DeleteUserRequestRegion | (string & {});
+    /** instance id */
+    instanceId: string;
+    /** user id */
+    userId: string;
+}
+export declare const DeleteUserRequest: S.Schema<DeleteUserRequest>;
+export interface DeleteUserResponse {
+}
+export declare const DeleteUserResponse: S.Schema<DeleteUserResponse>;
+export type GetBackupRequestRegion = "eu01" | "eu02";
+export declare const GetBackupRequestRegion: any;
+export interface GetBackupRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: GetBackupRequestRegion | (string & {});
+    /** instance id */
+    instanceId: string;
+    /** backup id */
+    backupId: string;
+}
+export declare const GetBackupRequest: S.Schema<GetBackupRequest>;
+export type BackupLabelsList = Array<string>;
+export declare const BackupLabelsList: S.Schema<BackupLabelsList>;
+export type BackupOptionsMap = {
+    [key: string]: string | undefined;
+};
+export declare const BackupOptionsMap: S.Schema<BackupOptionsMap>;
+export interface Backup {
+    endTime?: string;
+    error?: string;
+    id?: string;
+    labels?: BackupLabelsList;
+    name?: string;
+    options?: BackupOptionsMap;
+    size?: number;
+    startTime?: string;
+}
+export declare const Backup: S.Schema<Backup>;
+export interface GetBackupResponse {
+    item?: Backup;
+}
+export declare const GetBackupResponse: S.Schema<GetBackupResponse>;
+export type GetInstanceRequestRegion = "eu01" | "eu02";
+export declare const GetInstanceRequestRegion: any;
+export interface GetInstanceRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: GetInstanceRequestRegion | (string & {});
+    /** instance id */
+    instanceId: string;
+}
+export declare const GetInstanceRequest: S.Schema<GetInstanceRequest>;
+export interface Flavor {
+    cpu?: number;
+    description?: string;
+    id?: string;
+    memory?: number;
+}
+export declare const Flavor: S.Schema<Flavor>;
+export type InstanceOptionsMap = {
+    [key: string]: string | undefined;
+};
+export declare const InstanceOptionsMap: S.Schema<InstanceOptionsMap>;
+/** The current status of the instance. */
+export type InstanceStatus = "READY" | "PENDING" | "PROCESSING" | "FAILED" | "UNKNOWN";
+export declare const InstanceStatus: any;
+export interface Instance {
+    acl?: ACL;
+    backupSchedule?: string;
+    flavor?: Flavor;
+    id?: string;
+    name?: string;
+    options?: InstanceOptionsMap;
+    replicas?: number;
+    /** The current status of the instance. */
+    status?: InstanceStatus;
+    storage?: Storage;
+    version?: string;
+}
+export declare const Instance: S.Schema<Instance>;
+export interface InstanceResponse {
+    item?: Instance;
+}
+export declare const InstanceResponse: S.Schema<InstanceResponse>;
+export type GetUserRequestRegion = "eu01" | "eu02";
+export declare const GetUserRequestRegion: any;
+export interface GetUserRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: GetUserRequestRegion | (string & {});
+    /** instance id */
+    instanceId: string;
+    /** user id */
+    userId: string;
+}
+export declare const GetUserRequest: S.Schema<GetUserRequest>;
+/** The roles defined for a user. The *roles* attribute can contain the following values: 'read', 'readWrite', 'readAnyDatabase', 'readWriteAnyDatabase', 'stackitAdmin'. **The 'readAnyDatabase', 'readWriteAnyDatabase' and 'stackitAdmin' roles will always be created in the admin database.** */
+export type InstanceResponseUserRolesList = Array<string>;
+export declare const InstanceResponseUserRolesList: S.Schema<InstanceResponseUserRolesList>;
+export interface InstanceResponseUser {
+    database?: string;
+    host?: string;
+    id?: string;
+    port?: number;
+    /** The roles defined for a user. The *roles* attribute can contain the following values: 'read', 'readWrite', 'readAnyDatabase', 'readWriteAnyDatabase', 'stackitAdmin'. **The 'readAnyDatabase', 'readWriteAnyDatabase' and 'stackitAdmin' roles will always be created in the admin database.** */
+    roles?: InstanceResponseUserRolesList;
+    username?: string;
+}
+export declare const InstanceResponseUser: S.Schema<InstanceResponseUser>;
+export interface GetUserResponse {
+    item?: InstanceResponseUser;
+}
+export declare const GetUserResponse: S.Schema<GetUserResponse>;
+export type ListAdvisorSlowQueriesRequestRegion = "eu01" | "eu02";
+export declare const ListAdvisorSlowQueriesRequestRegion: any;
+export interface ListAdvisorSlowQueriesRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ListAdvisorSlowQueriesRequestRegion | (string & {});
+    /** instance id */
+    instanceId: string;
+}
+export declare const ListAdvisorSlowQueriesRequest: S.Schema<ListAdvisorSlowQueriesRequest>;
+export interface SlowQuery {
+    /** The raw log line pertaining to the slow query. */
+    line?: string;
+    /** The namespace in which the slow query ran. */
+    namespace?: string;
+}
+export declare const SlowQuery: S.Schema<SlowQuery>;
+/** A list of documents with information about slow queries as detected by the Performance Advisor. */
+export type HandlersInstancesSlowQueriesResponseSlowQueriesList = Array<SlowQuery>;
+export declare const HandlersInstancesSlowQueriesResponseSlowQueriesList: S.Schema<HandlersInstancesSlowQueriesResponseSlowQueriesList>;
+export interface HandlersInstancesSlowQueriesResponse {
+    /** A list of documents with information about slow queries as detected by the Performance Advisor. */
+    slowQueries?: HandlersInstancesSlowQueriesResponseSlowQueriesList;
+}
+export declare const HandlersInstancesSlowQueriesResponse: S.Schema<HandlersInstancesSlowQueriesResponse>;
+export type ListBackupsRequestRegion = "eu01" | "eu02";
+export declare const ListBackupsRequestRegion: any;
+export interface ListBackupsRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ListBackupsRequestRegion | (string & {});
+    /** instance id */
+    instanceId: string;
+}
+export declare const ListBackupsRequest: S.Schema<ListBackupsRequest>;
+export type ListBackupsResponseItemsList = Array<Backup>;
+export declare const ListBackupsResponseItemsList: S.Schema<ListBackupsResponseItemsList>;
+export interface ListBackupsResponse {
+    count?: number;
+    items?: ListBackupsResponseItemsList;
+}
+export declare const ListBackupsResponse: S.Schema<ListBackupsResponse>;
+export type ListFlavorsRequestRegion = "eu01" | "eu02";
+export declare const ListFlavorsRequestRegion: any;
+export interface ListFlavorsRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ListFlavorsRequestRegion | (string & {});
+}
+export declare const ListFlavorsRequest: S.Schema<ListFlavorsRequest>;
+export type InstanceFlavorCategoriesList = Array<string>;
+export declare const InstanceFlavorCategoriesList: S.Schema<InstanceFlavorCategoriesList>;
+export interface InstanceFlavor {
+    categories?: InstanceFlavorCategoriesList;
+    cpu?: number;
+    description?: string;
+    id?: string;
+    memory?: number;
+}
+export declare const InstanceFlavor: S.Schema<InstanceFlavor>;
+export type ListFlavorsResponseFlavorsList = Array<InstanceFlavor>;
+export declare const ListFlavorsResponseFlavorsList: S.Schema<ListFlavorsResponseFlavorsList>;
+export interface ListFlavorsResponse {
+    flavors?: ListFlavorsResponseFlavorsList;
+}
+export declare const ListFlavorsResponse: S.Schema<ListFlavorsResponse>;
+export type ListInstancesRequestRegion = "eu01" | "eu02";
+export declare const ListInstancesRequestRegion: any;
+export interface ListInstancesRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ListInstancesRequestRegion | (string & {});
+    /** instance tag */
+    tag: string;
+}
+export declare const ListInstancesRequest: S.Schema<ListInstancesRequest>;
+/** The current status of the instance. */
+export type InstanceListInstanceStatus = "READY" | "PENDING" | "PROCESSING" | "FAILED" | "UNKNOWN";
+export declare const InstanceListInstanceStatus: any;
+export interface InstanceListInstance {
+    id?: string;
+    name?: string;
+    /** The current status of the instance. */
+    status?: InstanceListInstanceStatus;
+}
+export declare const InstanceListInstance: S.Schema<InstanceListInstance>;
+export type ListInstancesResponseItemsList = Array<InstanceListInstance>;
+export declare const ListInstancesResponseItemsList: S.Schema<ListInstancesResponseItemsList>;
+export interface ListInstancesResponse {
+    count?: number;
+    items?: ListInstancesResponseItemsList;
+}
+export declare const ListInstancesResponse: S.Schema<ListInstancesResponse>;
+export type ListMetricsRequestRegion = "eu01" | "eu02";
+export declare const ListMetricsRequestRegion: any;
+export interface ListMetricsRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ListMetricsRequestRegion | (string & {});
+    /** instance id */
+    instanceId: string;
+    /** metric type */
+    metric: string;
+    /** granularity */
+    granularity: string;
+    /** period */
+    period?: string;
+    /** period start */
+    start?: string;
+    /** period end */
+    end?: string;
+}
+export declare const ListMetricsRequest: S.Schema<ListMetricsRequest>;
+export interface DataPoint {
+    timestamp?: string;
+    value?: number;
+}
+export declare const DataPoint: S.Schema<DataPoint>;
+export type HostMetricDatapointsList = Array<DataPoint>;
+export declare const HostMetricDatapointsList: S.Schema<HostMetricDatapointsList>;
+export interface HostMetric {
+    datapoints?: HostMetricDatapointsList;
+    name?: string;
+    units?: string;
+}
+export declare const HostMetric: S.Schema<HostMetric>;
+export type HostHostMetricsList = Array<HostMetric>;
+export declare const HostHostMetricsList: S.Schema<HostHostMetricsList>;
+export interface Host {
+    hostMetrics?: HostHostMetricsList;
+    id?: string;
+}
+export declare const Host: S.Schema<Host>;
+export type ListMetricsResponseHostsList = Array<Host>;
+export declare const ListMetricsResponseHostsList: S.Schema<ListMetricsResponseHostsList>;
+export interface ListMetricsResponse {
+    hosts?: ListMetricsResponseHostsList;
+}
+export declare const ListMetricsResponse: S.Schema<ListMetricsResponse>;
+export type ListRestoreJobsRequestRegion = "eu01" | "eu02";
+export declare const ListRestoreJobsRequestRegion: any;
+export interface ListRestoreJobsRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ListRestoreJobsRequestRegion | (string & {});
+    /** instance id */
+    instanceId: string;
+}
+export declare const ListRestoreJobsRequest: S.Schema<ListRestoreJobsRequest>;
+export interface RestoreInstanceStatus {
+    backupID?: string;
+    date?: string;
+    id?: string;
+    instanceId?: string;
+    status?: string;
+}
+export declare const RestoreInstanceStatus: S.Schema<RestoreInstanceStatus>;
+export type ListRestoreJobsResponseItemsList = Array<RestoreInstanceStatus>;
+export declare const ListRestoreJobsResponseItemsList: S.Schema<ListRestoreJobsResponseItemsList>;
+export interface ListRestoreJobsResponse {
+    items?: ListRestoreJobsResponseItemsList;
+}
+export declare const ListRestoreJobsResponse: S.Schema<ListRestoreJobsResponse>;
+export type ListStoragesRequestRegion = "eu01" | "eu02";
+export declare const ListStoragesRequestRegion: any;
+export interface ListStoragesRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ListStoragesRequestRegion | (string & {});
+    /** flavor id */
+    flavor: string;
+}
+export declare const ListStoragesRequest: S.Schema<ListStoragesRequest>;
+export type ListStoragesResponseStorageClassesList = Array<string>;
+export declare const ListStoragesResponseStorageClassesList: S.Schema<ListStoragesResponseStorageClassesList>;
+export interface StorageRange {
+    max?: number;
+    min?: number;
+}
+export declare const StorageRange: S.Schema<StorageRange>;
+export interface ListStoragesResponse {
+    storageClasses?: ListStoragesResponseStorageClassesList;
+    storageRange?: StorageRange;
+}
+export declare const ListStoragesResponse: S.Schema<ListStoragesResponse>;
+export type ListSuggestedIndexesRequestRegion = "eu01" | "eu02";
+export declare const ListSuggestedIndexesRequestRegion: any;
+export interface ListSuggestedIndexesRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ListSuggestedIndexesRequestRegion | (string & {});
+    /** instance id */
+    instanceId: string;
+}
+export declare const ListSuggestedIndexesRequest: S.Schema<ListSuggestedIndexesRequest>;
+/** Documents containing the search criteria used by the query. */
+export type MongodbatlasOperationPredicatesList = Array<unknown>;
+export declare const MongodbatlasOperationPredicatesList: S.Schema<MongodbatlasOperationPredicatesList>;
+export interface MongodbatlasStats {
+    /** Duration in milliseconds of the query. */
+    ms?: number;
+    /** Number of results returned by the query. */
+    nReturned?: number;
+    /** Number of documents read by the query. */
+    nScanned?: number;
+    /** Query timestamp, in seconds since epoch. */
+    ts?: number;
+}
+export declare const MongodbatlasStats: S.Schema<MongodbatlasStats>;
+export interface MongodbatlasOperation {
+    /** Documents containing the search criteria used by the query. */
+    predicates?: MongodbatlasOperationPredicatesList;
+    /** Raw log line produced by the query. */
+    raw?: string;
+    /** Query statistics. */
+    stats?: MongodbatlasStats;
+}
+export declare const MongodbatlasOperation: S.Schema<MongodbatlasOperation>;
+/** It represents documents with specific information and log lines for individual queries. */
+export type ShapeOperationsList = Array<MongodbatlasOperation>;
+export declare const ShapeOperationsList: S.Schema<ShapeOperationsList>;
+export interface Shape {
+    /** Average duration in milliseconds for the queries examined that match this shape. */
+    avgMs?: number;
+    /** Number of queries examined that match this shape. */
+    count?: number;
+    /** Unique id for this shape. Exists only for the duration of the API request. */
+    id?: string;
+    /** Average number of documents read for every document returned by the query. */
+    inefficiencyScore?: number;
+    /** The namespace in which the slow query ran. */
+    namespace?: string;
+    /** It represents documents with specific information and log lines for individual queries. */
+    operations?: ShapeOperationsList;
+}
+export declare const Shape: S.Schema<Shape>;
+/** Documents with information about the query shapes that are served by the suggested indexes. */
+export type HandlersInstancesSuggestedIndexesResponseShapesList = Array<Shape>;
+export declare const HandlersInstancesSuggestedIndexesResponseShapesList: S.Schema<HandlersInstancesSuggestedIndexesResponseShapesList>;
+/** List of unique identifiers which correspond the query shapes in this response which pertain to this suggested index. */
+export type SuggestedIndexImpactList = Array<string>;
+export declare const SuggestedIndexImpactList: S.Schema<SuggestedIndexImpactList>;
+export type SuggestedIndexIndexItemMap = {
+    [key: string]: number | undefined;
+};
+export declare const SuggestedIndexIndexItemMap: S.Schema<SuggestedIndexIndexItemMap>;
+/** Array of documents that specifies a key in the index and its sort order, ascending or descending. */
+export type SuggestedIndexIndexList = Array<SuggestedIndexIndexItemMap>;
+export declare const SuggestedIndexIndexList: S.Schema<SuggestedIndexIndexList>;
+export interface SuggestedIndex {
+    /** Unique id for this suggested index. */
+    id?: string;
+    /** List of unique identifiers which correspond the query shapes in this response which pertain to this suggested index. */
+    impact?: SuggestedIndexImpactList;
+    /** Array of documents that specifies a key in the index and its sort order, ascending or descending. */
+    index?: SuggestedIndexIndexList;
+    /** Namespace of the suggested index. */
+    namespace?: string;
+    /** Estimated percentage performance improvement that the suggested index would provide. */
+    weight?: number;
+}
+export declare const SuggestedIndex: S.Schema<SuggestedIndex>;
+/** Documents with information about the indexes suggested by the Performance Advisor. */
+export type HandlersInstancesSuggestedIndexesResponseSuggestedIndexesList = Array<SuggestedIndex>;
+export declare const HandlersInstancesSuggestedIndexesResponseSuggestedIndexesList: S.Schema<HandlersInstancesSuggestedIndexesResponseSuggestedIndexesList>;
+export interface HandlersInstancesSuggestedIndexesResponse {
+    /** Documents with information about the query shapes that are served by the suggested indexes. */
+    shapes?: HandlersInstancesSuggestedIndexesResponseShapesList;
+    /** Documents with information about the indexes suggested by the Performance Advisor. */
+    suggestedIndexes?: HandlersInstancesSuggestedIndexesResponseSuggestedIndexesList;
+}
+export declare const HandlersInstancesSuggestedIndexesResponse: S.Schema<HandlersInstancesSuggestedIndexesResponse>;
+export type ListUsersRequestRegion = "eu01" | "eu02";
+export declare const ListUsersRequestRegion: any;
+export interface ListUsersRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ListUsersRequestRegion | (string & {});
+    /** instance id */
+    instanceId: string;
+}
+export declare const ListUsersRequest: S.Schema<ListUsersRequest>;
+export interface ListUser {
+    id?: string;
+    username?: string;
+}
+export declare const ListUser: S.Schema<ListUser>;
+export type ListUsersResponseItemsList = Array<ListUser>;
+export declare const ListUsersResponseItemsList: S.Schema<ListUsersResponseItemsList>;
+export interface ListUsersResponse {
+    count?: number;
+    items?: ListUsersResponseItemsList;
+}
+export declare const ListUsersResponse: S.Schema<ListUsersResponse>;
+export type ListVersionsRequestRegion = "eu01" | "eu02";
+export declare const ListVersionsRequestRegion: any;
+export interface ListVersionsRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ListVersionsRequestRegion | (string & {});
+}
+export declare const ListVersionsRequest: S.Schema<ListVersionsRequest>;
+export type ListVersionsResponseVersionsList = Array<string>;
+export declare const ListVersionsResponseVersionsList: S.Schema<ListVersionsResponseVersionsList>;
+export interface ListVersionsResponse {
+    versions?: ListVersionsResponseVersionsList;
+}
+export declare const ListVersionsResponse: S.Schema<ListVersionsResponse>;
+export type PartialUpdateInstanceRequestRegion = "eu01" | "eu02";
+export declare const PartialUpdateInstanceRequestRegion: any;
+/** Labels field is not certain/clear */
+export type PartialUpdateInstanceRequestLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const PartialUpdateInstanceRequestLabelsMap: S.Schema<PartialUpdateInstanceRequestLabelsMap>;
+export type PartialUpdateInstanceRequestOptionsMap = {
+    [key: string]: string | undefined;
+};
+export declare const PartialUpdateInstanceRequestOptionsMap: S.Schema<PartialUpdateInstanceRequestOptionsMap>;
+export interface PartialUpdateInstanceRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: PartialUpdateInstanceRequestRegion | (string & {});
+    /** instance id */
+    instanceId: string;
+    acl?: ACL;
+    backupSchedule?: string;
+    flavorId?: string;
+    /** Labels field is not certain/clear */
+    labels?: PartialUpdateInstanceRequestLabelsMap;
+    name?: string;
+    options?: PartialUpdateInstanceRequestOptionsMap;
+    replicas?: number;
+    storage?: Storage;
+    version?: string;
+}
+export declare const PartialUpdateInstanceRequest: S.Schema<PartialUpdateInstanceRequest>;
+export interface UpdateInstanceResponse {
+    item?: Instance;
+}
+export declare const UpdateInstanceResponse: S.Schema<UpdateInstanceResponse>;
+export type PartialUpdateUserRequestRegion = "eu01" | "eu02";
+export declare const PartialUpdateUserRequestRegion: any;
+/** The roles defined for a user. Currently only one role in the list is supported, therefore only the first role from this list is used. The *roles* attribute can contain the following values: 'read', 'readWrite', 'readAnyDatabase', 'readWriteAnyDatabase', 'stackitAdmin'. **The 'readAnyDatabase', 'readWriteAnyDatabase' and 'stackitAdmin' roles will always be created in the admin database.** */
+export type PartialUpdateUserRequestRolesList = Array<string>;
+export declare const PartialUpdateUserRequestRolesList: S.Schema<PartialUpdateUserRequestRolesList>;
+export interface PartialUpdateUserRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: PartialUpdateUserRequestRegion | (string & {});
+    /** instance id */
+    instanceId: string;
+    /** user id */
+    userId: string;
+    database?: string;
+    /** The roles defined for a user. Currently only one role in the list is supported, therefore only the first role from this list is used. The *roles* attribute can contain the following values: 'read', 'readWrite', 'readAnyDatabase', 'readWriteAnyDatabase', 'stackitAdmin'. **The 'readAnyDatabase', 'readWriteAnyDatabase' and 'stackitAdmin' roles will always be created in the admin database.** */
+    roles?: PartialUpdateUserRequestRolesList;
+}
+export declare const PartialUpdateUserRequest: S.Schema<PartialUpdateUserRequest>;
+export interface PartialUpdateUserResponse {
+}
+export declare const PartialUpdateUserResponse: S.Schema<PartialUpdateUserResponse>;
+export type ResetUserRequestRegion = "eu01" | "eu02";
+export declare const ResetUserRequestRegion: any;
+export interface ResetUserRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ResetUserRequestRegion | (string & {});
+    /** instance id */
+    instanceId: string;
+    /** user id */
+    userId: string;
+}
+export declare const ResetUserRequest: S.Schema<ResetUserRequest>;
+export type RestoreInstanceRequestRegion = "eu01" | "eu02";
+export declare const RestoreInstanceRequestRegion: any;
+export interface RestoreInstanceRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: RestoreInstanceRequestRegion | (string & {});
+    /** instance id */
+    instanceId: string;
+    backupId: string;
+}
+export declare const RestoreInstanceRequest: S.Schema<RestoreInstanceRequest>;
+export interface RestoreInstanceResponse {
+    item?: RestoreInstanceStatus;
+}
+export declare const RestoreInstanceResponse: S.Schema<RestoreInstanceResponse>;
+export type UpdateBackupScheduleRequestRegion = "eu01" | "eu02";
+export declare const UpdateBackupScheduleRequestRegion: any;
+export interface UpdateBackupScheduleRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: UpdateBackupScheduleRequestRegion | (string & {});
+    /** instance id */
+    instanceId: string;
+    backupSchedule?: string;
+    dailySnapshotRetentionDays?: number;
+    monthlySnapshotRetentionMonths?: number;
+    pointInTimeWindowHours?: number;
+    snapshotRetentionDays?: number;
+    weeklySnapshotRetentionWeeks?: number;
+}
+export declare const UpdateBackupScheduleRequest: S.Schema<UpdateBackupScheduleRequest>;
+export interface BackupSchedule {
+    backupSchedule?: string;
+    dailySnapshotRetentionDays?: number;
+    monthlySnapshotRetentionMonths?: number;
+    pointInTimeWindowHours?: number;
+    snapshotRetentionDays?: number;
+    weeklySnapshotRetentionWeeks?: number;
+}
+export declare const BackupSchedule: S.Schema<BackupSchedule>;
+export type UpdateInstanceRequestRegion = "eu01" | "eu02";
+export declare const UpdateInstanceRequestRegion: any;
+/** Labels field is not certain/clear */
+export type UpdateInstanceRequestLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const UpdateInstanceRequestLabelsMap: S.Schema<UpdateInstanceRequestLabelsMap>;
+export type UpdateInstanceRequestOptionsMap = {
+    [key: string]: string | undefined;
+};
+export declare const UpdateInstanceRequestOptionsMap: S.Schema<UpdateInstanceRequestOptionsMap>;
+export interface UpdateInstanceRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: UpdateInstanceRequestRegion | (string & {});
+    /** instance id */
+    instanceId: string;
+    acl: ACL;
+    backupSchedule: string;
+    flavorId: string;
+    /** Labels field is not certain/clear */
+    labels?: UpdateInstanceRequestLabelsMap;
+    name: string;
+    options: UpdateInstanceRequestOptionsMap;
+    replicas: number;
+    storage: Storage;
+    version: string;
+}
+export declare const UpdateInstanceRequest: S.Schema<UpdateInstanceRequest>;
+export type UpdateUserRequestRegion = "eu01" | "eu02";
+export declare const UpdateUserRequestRegion: any;
+/** The roles defined for a user. Currently only one role in the list is supported, therefore only the first role from this list is used. The *roles* attribute can contain the following values: 'read', 'readWrite', 'readAnyDatabase', 'readWriteAnyDatabase', 'stackitAdmin'. **The 'readAnyDatabase', 'readWriteAnyDatabase' and 'stackitAdmin' roles will always be created in the admin database.** */
+export type UpdateUserRequestRolesList = Array<string>;
+export declare const UpdateUserRequestRolesList: S.Schema<UpdateUserRequestRolesList>;
+export interface UpdateUserRequest {
+    /** project id */
+    projectId: string;
+    /** The region which should be addressed */
+    region: UpdateUserRequestRegion | (string & {});
+    /** instance id */
+    instanceId: string;
+    /** user id */
+    userId: string;
+    database: string;
+    /** The roles defined for a user. Currently only one role in the list is supported, therefore only the first role from this list is used. The *roles* attribute can contain the following values: 'read', 'readWrite', 'readAnyDatabase', 'readWriteAnyDatabase', 'stackitAdmin'. **The 'readAnyDatabase', 'readWriteAnyDatabase' and 'stackitAdmin' roles will always be created in the admin database.** */
+    roles: UpdateUserRequestRolesList;
+}
+export declare const UpdateUserRequest: S.Schema<UpdateUserRequest>;
+export interface UpdateUserResponse {
+}
+export declare const UpdateUserResponse: S.Schema<UpdateUserResponse>;
+export type CloneInstanceError = BadRequest | NotFound | StackitOpError;
+/** Clone instance Clone an instance via PIT restore<br/> Note that the Timestamp is a RFC3339 standard and uses by default UTC time format<br/> As an example a valid timestamp look like "2023-04-20T15:05:15Z" */
+export declare const cloneInstance: API.OperationMethod<CloneInstanceRequest, CloneInstanceResponse, CloneInstanceError, StackitOpContext>;
+export type CreateInstanceError = BadRequest | NotFound | StackitOpError;
+/** Create instance Create and deploys an instance<br/> Note that the time format for the backupSchedule is in UTC */
+export declare const createInstance: API.OperationMethod<CreateInstanceRequest, CreateInstanceResponse, CreateInstanceError, StackitOpContext>;
+export type CreateUserError = BadRequest | NotFound | Conflict | StackitOpError;
+/** Create User create a new user for a mongodb instance */
+export declare const createUser: API.OperationMethod<CreateUserRequest, CreateUserResponse, CreateUserError, StackitOpContext>;
+export type DeleteInstanceError = BadRequest | NotFound | StackitOpError;
+/** Delete instance removes an instance */
+export declare const deleteInstance: API.OperationMethod<DeleteInstanceRequest, DeleteInstanceResponse, DeleteInstanceError, StackitOpContext>;
+export type DeleteUserError = BadRequest | NotFound | StackitOpError;
+/** Delete User delete mongodb user */
+export declare const deleteUser: API.OperationMethod<DeleteUserRequest, DeleteUserResponse, DeleteUserError, StackitOpContext>;
+export type GetBackupError = BadRequest | NotFound | StackitOpError;
+/** Get backup Get details about a specific backup */
+export declare const getBackup: API.OperationMethod<GetBackupRequest, GetBackupResponse, GetBackupError, StackitOpContext>;
+export type GetInstanceError = BadRequest | StackitOpError;
+/** Get instance gets information of an instance */
+export declare const getInstance: API.OperationMethod<GetInstanceRequest, InstanceResponse, GetInstanceError, StackitOpContext>;
+export type GetUserError = BadRequest | NotFound | StackitOpError;
+/** Get User get detailed information of a user of a mongodb instance */
+export declare const getUser: API.OperationMethod<GetUserRequest, GetUserResponse, GetUserError, StackitOpContext>;
+export type ListAdvisorSlowQueriesError = BadRequest | NotFound | StackitOpError;
+/** Get slow queries gets slow queries from the Opsmanager performance advisor */
+export declare const listAdvisorSlowQueries: API.OperationMethod<ListAdvisorSlowQueriesRequest, HandlersInstancesSlowQueriesResponse, ListAdvisorSlowQueriesError, StackitOpContext>;
+export type ListBackupsError = BadRequest | NotFound | StackitOpError;
+/** List backup List backups of an instance */
+export declare const listBackups: API.OperationMethod<ListBackupsRequest, ListBackupsResponse, ListBackupsError, StackitOpContext>;
+export type ListFlavorsError = BadRequest | StackitOpError;
+/** Flavors returns all possible flavors */
+export declare const listFlavors: API.OperationMethod<ListFlavorsRequest, ListFlavorsResponse, ListFlavorsError, StackitOpContext>;
+export type ListInstancesError = BadRequest | StackitOpError;
+/** List Instances list all instances for a projectID */
+export declare const listInstances: API.OperationMethod<ListInstancesRequest, ListInstancesResponse, ListInstancesError, StackitOpContext>;
+export type ListMetricsError = BadRequest | NotFound | StackitOpError;
+/** Metrics returns metrics for an instance */
+export declare const listMetrics: API.OperationMethod<ListMetricsRequest, ListMetricsResponse, ListMetricsError, StackitOpContext>;
+export type ListRestoreJobsError = BadRequest | NotFound | StackitOpError;
+/** List restore jobs List restore jobs of an instance */
+export declare const listRestoreJobs: API.OperationMethod<ListRestoreJobsRequest, ListRestoreJobsResponse, ListRestoreJobsError, StackitOpContext>;
+export type ListStoragesError = BadRequest | NotFound | StackitOpError;
+/** Get storage returns the storage for a certain flavor */
+export declare const listStorages: API.OperationMethod<ListStoragesRequest, ListStoragesResponse, ListStoragesError, StackitOpContext>;
+export type ListSuggestedIndexesError = BadRequest | NotFound | StackitOpError;
+/** Get suggested indexes gets suggested indexes from the Opsmanager performance advisor */
+export declare const listSuggestedIndexes: API.OperationMethod<ListSuggestedIndexesRequest, HandlersInstancesSuggestedIndexesResponse, ListSuggestedIndexesError, StackitOpContext>;
+export type ListUsersError = BadRequest | NotFound | StackitOpError;
+/** List Users list all users for a mongodb instance */
+export declare const listUsers: API.OperationMethod<ListUsersRequest, ListUsersResponse, ListUsersError, StackitOpContext>;
+export type ListVersionsError = BadRequest | StackitOpError;
+/** Get versions returns all available versions for creating endpoint */
+export declare const listVersions: API.OperationMethod<ListVersionsRequest, ListVersionsResponse, ListVersionsError, StackitOpContext>;
+export type PartialUpdateInstanceError = BadRequest | NotFound | Conflict | StackitOpError;
+/** Patch endpoint Updates a deployment plan<br/> Note that the time format for the backupSchedule is in UTC */
+export declare const partialUpdateInstance: API.OperationMethod<PartialUpdateInstanceRequest, UpdateInstanceResponse, PartialUpdateInstanceError, StackitOpContext>;
+export type PartialUpdateUserError = BadRequest | NotFound | Conflict | StackitOpError;
+/** Update User updates user for a mongodb instance */
+export declare const partialUpdateUser: API.OperationMethod<PartialUpdateUserRequest, PartialUpdateUserResponse, PartialUpdateUserError, StackitOpContext>;
+export type ResetUserError = BadRequest | NotFound | StackitOpError;
+/** Reset User resets mongodb user's password */
+export declare const resetUser: API.OperationMethod<ResetUserRequest, User, ResetUserError, StackitOpContext>;
+export type RestoreInstanceError = BadRequest | NotFound | StackitOpError;
+/** Restore instance Restore an instance based on snapshot */
+export declare const restoreInstance: API.OperationMethod<RestoreInstanceRequest, RestoreInstanceResponse, RestoreInstanceError, StackitOpContext>;
+export type UpdateBackupScheduleError = BadRequest | NotFound | StackitOpError;
+/** Update schedule Updates a backup schedule<br/> Note that the time format is in UTC */
+export declare const updateBackupSchedule: API.OperationMethod<UpdateBackupScheduleRequest, BackupSchedule, UpdateBackupScheduleError, StackitOpContext>;
+export type UpdateInstanceError = BadRequest | NotFound | Conflict | StackitOpError;
+/** Put endpoint Updates a deployment plan<br/> Note that the time format for the backupSchedule is in UTC */
+export declare const updateInstance: API.OperationMethod<UpdateInstanceRequest, UpdateInstanceResponse, UpdateInstanceError, StackitOpContext>;
+export type UpdateUserError = BadRequest | NotFound | Conflict | StackitOpError;
+/** Update User updates user for a mongodb instance */
+export declare const updateUser: API.OperationMethod<UpdateUserRequest, UpdateUserResponse, UpdateUserError, StackitOpContext>;
+//# sourceMappingURL=mongodb_flex.d.ts.map