@distilled.cloud/stackit 0.0.0-placeholder → 1.0.0-rc.13

package/lib/services/sqlserverflex.d.ts

@@ -0,0 +1,956 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as Redacted from "effect/Redacted";
+import * as API from "@distilled.cloud/core/api";
+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 Forbidden_base: S.Class<Forbidden, S.TaggedStruct<"Forbidden", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        AuthError: true;
+    };
+});
+export declare class Forbidden extends /*@__PURE__*/ Forbidden_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 {
+}
+declare const UnprocessableEntity_base: S.Class<UnprocessableEntity, S.TaggedStruct<"UnprocessableEntity", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class UnprocessableEntity extends /*@__PURE__*/ UnprocessableEntity_base {
+}
+export type CreateDatabaseRequestRegion = "eu01";
+export declare const CreateDatabaseRequestRegion: any;
+export interface CreateDatabaseRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: CreateDatabaseRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    collation?: string;
+    compatibility?: number;
+    name: string;
+    owner: string;
+}
+export declare const CreateDatabaseRequest: S.Schema<CreateDatabaseRequest>;
+export interface CreateDatabaseResponse {
+    id: number;
+}
+export declare const CreateDatabaseResponse: S.Schema<CreateDatabaseResponse>;
+export type CreateInstanceRequestRegion = "eu01";
+export declare const CreateInstanceRequestRegion: any;
+/** this defines which key to use for storage encryption */
+export interface InstanceEncryption {
+    /** The key identifier */
+    kekKeyId: string;
+    /** The keyring identifier */
+    kekKeyRingId: string;
+    /** The key version */
+    kekKeyVersion: string;
+    serviceAccount: string;
+}
+export declare const InstanceEncryption: S.Schema<InstanceEncryption>;
+/** A dictionary of user-defined key-value pairs used to categorize or organize the resource. **Rules for Keys:** * Must be between 1 and 63 characters long. * Must begin and end with an alphanumeric character (`[a-z0-9A-Z]`). * May contain dashes (`-`), underscores (`_`), and dots (`.`). * **Regex:** `^(?=.{1,63}$)([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9]$` * **Restriction:** The prefix `stackit-` is strictly reserved and cannot be used. **Rules for Values:** * Must be between 0 (empty string) and 63 characters long. * If not empty, must begin and end with an alphanumeric character. * May contain dashes (`-`), underscores (`_`), and dots (`.`). * **Regex:** `^(?=.{0,63}$)(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])*$` */
+export type Labels = {
+    [key: string]: string | undefined;
+};
+export declare const Labels: S.Schema<Labels>;
+/** The network access scope of the instance ⚠️ **Note:** This feature is in private preview. Supplying this object is only permitted for enabled accounts. If your account does not have access, the request will be rejected. */
+export type InstanceNetworkAccessScope = "PUBLIC" | "SNA";
+export declare const InstanceNetworkAccessScope: any;
+/** List of IPV4 cidr. */
+export type Acl = Array<string>;
+export declare const Acl: S.Schema<Acl>;
+/** the network configuration of the instance. */
+export interface CreateInstanceRequestNetwork {
+    accessScope?: InstanceNetworkAccessScope | (string & {});
+    acl: Acl;
+}
+export declare const CreateInstanceRequestNetwork: S.Schema<CreateInstanceRequestNetwork>;
+/** The object containing information about the storage size and class. */
+export interface StorageCreate {
+    class: string;
+    size: number;
+}
+export declare const StorageCreate: S.Schema<StorageCreate>;
+/** The sqlserver version used for the instance. */
+export type InstanceVersion = "2022";
+export declare const InstanceVersion: any;
+export interface CreateInstanceRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: CreateInstanceRequestRegion | (string & {});
+    backupSchedule: string;
+    encryption?: InstanceEncryption;
+    flavorId: string;
+    labels?: Labels;
+    name: string;
+    /** the network configuration of the instance. */
+    network: CreateInstanceRequestNetwork;
+    retentionDays: number;
+    storage: StorageCreate;
+    version: InstanceVersion | (string & {});
+}
+export declare const CreateInstanceRequest: S.Schema<CreateInstanceRequest>;
+export interface CreateInstanceResponse {
+    id: string;
+}
+export declare const CreateInstanceResponse: S.Schema<CreateInstanceResponse>;
+export type CreateUserRequestRegion = "eu01";
+export declare const CreateUserRequestRegion: any;
+/** A list containing the user roles for the instance. A list with the valid user roles can be retrieved using the List Roles endpoint. */
+export type CreateUserRequestRolesList = Array<string>;
+export declare const CreateUserRequestRolesList: S.Schema<CreateUserRequestRolesList>;
+export interface CreateUserRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: CreateUserRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    default_database?: string;
+    /** A list containing the user roles for the instance. A list with the valid user roles can be retrieved using the List Roles endpoint. */
+    roles: CreateUserRequestRolesList;
+    username: string;
+}
+export declare const CreateUserRequest: S.Schema<CreateUserRequest>;
+export type CreateUserResponseRolesList = Array<string>;
+export declare const CreateUserResponseRolesList: S.Schema<CreateUserResponseRolesList>;
+export interface CreateUserResponse {
+    default_database: string;
+    host: string;
+    id: number;
+    password: string | Redacted.Redacted<string>;
+    port: number;
+    roles: CreateUserResponseRolesList;
+    status: string;
+    uri: string;
+    username: string;
+}
+export declare const CreateUserResponse: S.Schema<CreateUserResponse>;
+export type DeleteDatabaseRequestRegion = "eu01";
+export declare const DeleteDatabaseRequestRegion: any;
+export interface DeleteDatabaseRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: DeleteDatabaseRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    /** The name of the database. */
+    databaseName: string;
+}
+export declare const DeleteDatabaseRequest: S.Schema<DeleteDatabaseRequest>;
+export interface DeleteDatabaseResponse {
+}
+export declare const DeleteDatabaseResponse: S.Schema<DeleteDatabaseResponse>;
+export type DeleteInstanceRequestRegion = "eu01";
+export declare const DeleteInstanceRequestRegion: any;
+export interface DeleteInstanceRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: DeleteInstanceRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+}
+export declare const DeleteInstanceRequest: S.Schema<DeleteInstanceRequest>;
+export interface DeleteInstanceResponse {
+}
+export declare const DeleteInstanceResponse: S.Schema<DeleteInstanceResponse>;
+export type DeleteUserRequestRegion = "eu01";
+export declare const DeleteUserRequestRegion: any;
+export interface DeleteUserRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: DeleteUserRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    /** The ID of the user. */
+    userId: number;
+}
+export declare const DeleteUserRequest: S.Schema<DeleteUserRequest>;
+export interface DeleteUserResponse {
+}
+export declare const DeleteUserResponse: S.Schema<DeleteUserResponse>;
+export type GetBackupRequestRegion = "eu01";
+export declare const GetBackupRequestRegion: any;
+export interface GetBackupRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: GetBackupRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    /** The ID of the backup. */
+    backupId: number;
+}
+export declare const GetBackupRequest: S.Schema<GetBackupRequest>;
+export interface GetBackupResponse {
+    completionTime: string;
+    id: number;
+    name: string;
+    retainedUntil: string;
+    size: number;
+    type: string;
+}
+export declare const GetBackupResponse: S.Schema<GetBackupResponse>;
+export type GetDatabaseRequestRegion = "eu01";
+export declare const GetDatabaseRequestRegion: any;
+export interface GetDatabaseRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: GetDatabaseRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    /** The name of the database. */
+    databaseName: string;
+}
+export declare const GetDatabaseRequest: S.Schema<GetDatabaseRequest>;
+export interface GetDatabaseResponse {
+    collationName: string;
+    compatibilityLevel: number;
+    id: number;
+    name: string;
+    owner: string;
+}
+export declare const GetDatabaseResponse: S.Schema<GetDatabaseResponse>;
+export type GetInstanceRequestRegion = "eu01";
+export declare const GetInstanceRequestRegion: any;
+export interface GetInstanceRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: GetInstanceRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+}
+export declare const GetInstanceRequest: S.Schema<GetInstanceRequest>;
+/** Edition of the MSSQL server instance */
+export type InstanceEdition = "Standard" | "EnterpriseCore" | "developer";
+export declare const InstanceEdition: any;
+/** The access configuration of the instance */
+export interface InstanceNetwork {
+    accessScope?: InstanceNetworkAccessScope;
+    acl?: Acl;
+    instanceAddress?: string;
+    routerAddress?: string;
+}
+export declare const InstanceNetwork: S.Schema<InstanceNetwork>;
+/** How many replicas the instance should have. */
+export type Replicas = 1 | 3;
+export declare const Replicas: any;
+export type State = "READY" | "PENDING" | "PROGRESSING" | "FAILURE" | "UNKNOWN" | "TERMINATING";
+export declare const State: any;
+/** The object containing information about the storage size and class. */
+export interface Storage {
+    class?: string;
+    size?: number;
+}
+export declare const Storage: S.Schema<Storage>;
+export interface GetInstanceResponse {
+    backupSchedule: string;
+    edition: InstanceEdition;
+    encryption?: InstanceEncryption;
+    flavorId: string;
+    id: string;
+    isDeletable: boolean;
+    labels?: Labels;
+    name: string;
+    network: InstanceNetwork;
+    replicas: Replicas;
+    retentionDays: number;
+    state: State;
+    storage: Storage;
+    version: InstanceVersion;
+}
+export declare const GetInstanceResponse: S.Schema<GetInstanceResponse>;
+export type GetUserRequestRegion = "eu01";
+export declare const GetUserRequestRegion: any;
+export interface GetUserRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: GetUserRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    /** The ID of the user. */
+    userId: number;
+}
+export declare const GetUserRequest: S.Schema<GetUserRequest>;
+/** A list of user roles. */
+export type GetUserResponseRolesList = Array<string>;
+export declare const GetUserResponseRolesList: S.Schema<GetUserResponseRolesList>;
+export interface GetUserResponse {
+    default_database: string;
+    host: string;
+    id: number;
+    port: number;
+    /** A list of user roles. */
+    roles: GetUserResponseRolesList;
+    status: string;
+    username: string;
+}
+export declare const GetUserResponse: S.Schema<GetUserResponse>;
+export type ListBackupsRequestRegion = "eu01";
+export declare const ListBackupsRequestRegion: any;
+export type BackupSort = "end_time.desc" | "end_time.asc" | "index.desc" | "index.asc" | "name.desc" | "name.asc" | "retained_until.desc" | "retained_until.asc" | "size.desc" | "size.asc" | "type.desc" | "type.asc";
+export declare const BackupSort: any;
+export interface ListBackupsRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ListBackupsRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    /** Number of the page of items list to be returned. */
+    page?: number;
+    /** Number of items to be returned on each page. */
+    size?: number;
+    /** Sorting of the backups to be returned on each page. */
+    sort?: BackupSort | (string & {});
+}
+export declare const ListBackupsRequest: S.Schema<ListBackupsRequest>;
+export interface ListBackup {
+    completionTime: string;
+    id: number;
+    name: string;
+    retainedUntil: string;
+    size: number;
+    type: string;
+}
+export declare const ListBackup: S.Schema<ListBackup>;
+/** List of the backups beloning to that database */
+export type ListBackupsResponseBackupsList = Array<ListBackup>;
+export declare const ListBackupsResponseBackupsList: S.Schema<ListBackupsResponseBackupsList>;
+export interface ListBackupsResponse {
+    /** List of the backups beloning to that database */
+    backups: ListBackupsResponseBackupsList;
+    /** Name of the database the backups belong to */
+    databaseName: string;
+}
+export declare const ListBackupsResponse: S.Schema<ListBackupsResponse>;
+/** The list containing the information about the backups. */
+export type ListBackupResponseBackupsList = Array<ListBackupsResponse>;
+export declare const ListBackupResponseBackupsList: S.Schema<ListBackupResponseBackupsList>;
+export interface Pagination {
+    page: number;
+    size: number;
+    sort: string;
+    totalPages: number;
+    totalRows: number;
+}
+export declare const Pagination: S.Schema<Pagination>;
+export interface ListBackupResponse {
+    /** The list containing the information about the backups. */
+    backups: ListBackupResponseBackupsList;
+    pagination: Pagination;
+}
+export declare const ListBackupResponse: S.Schema<ListBackupResponse>;
+export type ListCollationsRequestRegion = "eu01";
+export declare const ListCollationsRequestRegion: any;
+export interface ListCollationsRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ListCollationsRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+}
+export declare const ListCollationsRequest: S.Schema<ListCollationsRequest>;
+export interface DatabaseGetcollation {
+    collation_name?: string;
+    description?: string;
+}
+export declare const DatabaseGetcollation: S.Schema<DatabaseGetcollation>;
+/** List of collations available for the instance. */
+export type ListCollationsResponseCollationsList = Array<DatabaseGetcollation>;
+export declare const ListCollationsResponseCollationsList: S.Schema<ListCollationsResponseCollationsList>;
+export interface ListCollationsResponse {
+    /** List of collations available for the instance. */
+    collations: ListCollationsResponseCollationsList;
+}
+export declare const ListCollationsResponse: S.Schema<ListCollationsResponse>;
+export type ListCompatibilitiesRequestRegion = "eu01";
+export declare const ListCompatibilitiesRequestRegion: any;
+export interface ListCompatibilitiesRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ListCompatibilitiesRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+}
+export declare const ListCompatibilitiesRequest: S.Schema<ListCompatibilitiesRequest>;
+export interface DatabaseGetcompatibility {
+    compatibility_level?: number;
+    description?: string;
+}
+export declare const DatabaseGetcompatibility: S.Schema<DatabaseGetcompatibility>;
+/** List of compatibilities available for a d */
+export type ListCompatibilityResponseCompatibilitiesList = Array<DatabaseGetcompatibility>;
+export declare const ListCompatibilityResponseCompatibilitiesList: S.Schema<ListCompatibilityResponseCompatibilitiesList>;
+export interface ListCompatibilityResponse {
+    /** List of compatibilities available for a d */
+    compatibilities: ListCompatibilityResponseCompatibilitiesList;
+}
+export declare const ListCompatibilityResponse: S.Schema<ListCompatibilityResponse>;
+export type ListCurrentRunningRestoreJobsRequestRegion = "eu01";
+export declare const ListCurrentRunningRestoreJobsRequestRegion: any;
+export interface ListCurrentRunningRestoreJobsRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ListCurrentRunningRestoreJobsRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+}
+export declare const ListCurrentRunningRestoreJobsRequest: S.Schema<ListCurrentRunningRestoreJobsRequest>;
+export interface BackupRunningRestore {
+    /** the command that was executed */
+    command: string;
+    /** the name of the database that is being restored */
+    database_name: string;
+    /** the projected time when the restore should be completed */
+    estimated_completion_time: string;
+    /** the percentage of the current running restore job */
+    percent_complete: number;
+    /** the start time of the current running restore job */
+    start_time: string;
+}
+export declare const BackupRunningRestore: S.Schema<BackupRunningRestore>;
+/** List of the currently running Restore jobs */
+export type ListCurrentRunningRestoreJobsRunningRestoresList = Array<BackupRunningRestore>;
+export declare const ListCurrentRunningRestoreJobsRunningRestoresList: S.Schema<ListCurrentRunningRestoreJobsRunningRestoresList>;
+export interface ListCurrentRunningRestoreJobs {
+    /** List of the currently running Restore jobs */
+    runningRestores: ListCurrentRunningRestoreJobsRunningRestoresList;
+}
+export declare const ListCurrentRunningRestoreJobs: S.Schema<ListCurrentRunningRestoreJobs>;
+export type ListDatabasesRequestRegion = "eu01";
+export declare const ListDatabasesRequestRegion: any;
+export type DatabaseSort = "created_at.desc" | "created_at.asc" | "database_id.desc" | "database_id.asc" | "database_name.desc" | "database_name.asc" | "database_owner.desc" | "database_owner.asc" | "index.asc" | "index.desc";
+export declare const DatabaseSort: any;
+export interface ListDatabasesRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ListDatabasesRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    /** Number of the page of items list to be returned. */
+    page?: number;
+    /** Number of items to be returned on each page. */
+    size?: number;
+    /** Sorting of the databases to be returned on each page. */
+    sort?: DatabaseSort | (string & {});
+}
+export declare const ListDatabasesRequest: S.Schema<ListDatabasesRequest>;
+export interface ListDatabase {
+    created: string;
+    id: number;
+    name: string;
+    owner: string;
+}
+export declare const ListDatabase: S.Schema<ListDatabase>;
+/** A list containing all databases for the instance. */
+export type ListDatabasesResponseDatabasesList = Array<ListDatabase>;
+export declare const ListDatabasesResponseDatabasesList: S.Schema<ListDatabasesResponseDatabasesList>;
+export interface ListDatabasesResponse {
+    /** A list containing all databases for the instance. */
+    databases: ListDatabasesResponseDatabasesList;
+    pagination: Pagination;
+}
+export declare const ListDatabasesResponse: S.Schema<ListDatabasesResponse>;
+export type ListFlavorsRequestRegion = "eu01";
+export declare const ListFlavorsRequestRegion: any;
+export type FlavorSort = "index.desc" | "index.asc" | "cpu.desc" | "cpu.asc" | "flavor_description.asc" | "flavor_description.desc" | "id.desc" | "id.asc" | "size_max.desc" | "size_max.asc" | "ram.desc" | "ram.asc" | "size_min.desc" | "size_min.asc" | "storage_class.asc" | "storage_class.desc" | "node_type.asc" | "node_type.desc";
+export declare const FlavorSort: any;
+export interface ListFlavorsRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ListFlavorsRequestRegion | (string & {});
+    /** Number of the page of items list to be returned. */
+    page?: number;
+    /** Number of items to be returned on each page. */
+    size?: number;
+    /** Sorting of the flavors to be returned on each page. */
+    sort?: FlavorSort | (string & {});
+}
+export declare const ListFlavorsRequest: S.Schema<ListFlavorsRequest>;
+/** a storageClass defines how efficient the storage can work */
+export interface FlavorStorageClassesStorageClass {
+    class: string;
+    maxIoPerSec: number;
+    maxThroughInMb: number;
+}
+export declare const FlavorStorageClassesStorageClass: S.Schema<FlavorStorageClassesStorageClass>;
+/** maximum storage which can be ordered for the flavor in Gigabyte. */
+export type FlavorStorageClasses = Array<FlavorStorageClassesStorageClass>;
+export declare const FlavorStorageClasses: S.Schema<FlavorStorageClasses>;
+/** The flavor of the instance containing the technical features. */
+export interface ListFlavors {
+    cpu: number;
+    description: string;
+    id: string;
+    maxGB: number;
+    memory: number;
+    minGB: number;
+    nodeType: string;
+    storageClasses: FlavorStorageClasses;
+}
+export declare const ListFlavors: S.Schema<ListFlavors>;
+/** List of flavors available for the project. */
+export type ListFlavorsResponseFlavorsList = Array<ListFlavors>;
+export declare const ListFlavorsResponseFlavorsList: S.Schema<ListFlavorsResponseFlavorsList>;
+export interface ListFlavorsResponse {
+    /** List of flavors available for the project. */
+    flavors: ListFlavorsResponseFlavorsList;
+    pagination: Pagination;
+}
+export declare const ListFlavorsResponse: S.Schema<ListFlavorsResponse>;
+export type ListInstancesRequestRegion = "eu01";
+export declare const ListInstancesRequestRegion: any;
+export type InstanceSort = "index.desc" | "index.asc" | "id.desc" | "id.asc" | "is_deletable.desc" | "is_deletable.asc" | "name.asc" | "name.desc" | "state.asc" | "state.desc";
+export declare const InstanceSort: any;
+export interface ListInstancesRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ListInstancesRequestRegion | (string & {});
+    /** Number of the page of items list to be returned. */
+    page?: number;
+    /** Number of items to be returned on each page. */
+    size?: number;
+    /** Sorting of the items to be returned on each page. */
+    sort?: InstanceSort | (string & {});
+}
+export declare const ListInstancesRequest: S.Schema<ListInstancesRequest>;
+export interface ListInstance {
+    id: string;
+    isDeletable: boolean;
+    name: string;
+    state: State;
+}
+export declare const ListInstance: S.Schema<ListInstance>;
+/** List of owned instances and their current status. */
+export type ListInstancesResponseInstancesList = Array<ListInstance>;
+export declare const ListInstancesResponseInstancesList: S.Schema<ListInstancesResponseInstancesList>;
+export interface ListInstancesResponse {
+    /** List of owned instances and their current status. */
+    instances: ListInstancesResponseInstancesList;
+    pagination: Pagination;
+}
+export declare const ListInstancesResponse: S.Schema<ListInstancesResponse>;
+export type ListRolesRequestRegion = "eu01";
+export declare const ListRolesRequestRegion: any;
+export interface ListRolesRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ListRolesRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+}
+export declare const ListRolesRequest: S.Schema<ListRolesRequest>;
+/** List of roles available for an instance. */
+export type ListRolesResponseRolesList = Array<string>;
+export declare const ListRolesResponseRolesList: S.Schema<ListRolesResponseRolesList>;
+export interface ListRolesResponse {
+    /** List of roles available for an instance. */
+    roles: ListRolesResponseRolesList;
+}
+export declare const ListRolesResponse: S.Schema<ListRolesResponse>;
+export type ListStoragesRequestRegion = "eu01";
+export declare const ListStoragesRequestRegion: any;
+export interface ListStoragesRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ListStoragesRequestRegion | (string & {});
+    /** The id of an instance flavor. */
+    flavorId: string;
+}
+export declare const ListStoragesRequest: S.Schema<ListStoragesRequest>;
+/** range of maximum and minimum storage which can be ordered for the flavor in Gigabyte. */
+export interface FlavorStorageRange {
+    max: number;
+    min: number;
+}
+export declare const FlavorStorageRange: S.Schema<FlavorStorageRange>;
+export interface ListStoragesResponse {
+    storageClasses: FlavorStorageClasses;
+    storageRange: FlavorStorageRange;
+}
+export declare const ListStoragesResponse: S.Schema<ListStoragesResponse>;
+export type ListUsersRequestRegion = "eu01";
+export declare const ListUsersRequestRegion: any;
+export type UserSort = "id.asc" | "id.desc" | "index.desc" | "index.asc" | "name.desc" | "name.asc" | "status.desc" | "status.asc";
+export declare const UserSort: any;
+export interface ListUsersRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ListUsersRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    /** Number of the page of items list to be returned. */
+    page?: number;
+    /** Number of items to be returned on each page. */
+    size?: number;
+    /** Sorting of the users to be returned on each page. */
+    sort?: UserSort | (string & {});
+}
+export declare const ListUsersRequest: S.Schema<ListUsersRequest>;
+export interface ListUser {
+    id: number;
+    status: string;
+    username: string;
+}
+export declare const ListUser: S.Schema<ListUser>;
+/** List of all users inside an instance */
+export type ListUserResponseUsersList = Array<ListUser>;
+export declare const ListUserResponseUsersList: S.Schema<ListUserResponseUsersList>;
+export interface ListUserResponse {
+    pagination: Pagination;
+    /** List of all users inside an instance */
+    users: ListUserResponseUsersList;
+}
+export declare const ListUserResponse: S.Schema<ListUserResponse>;
+export type ListVersionsRequestRegion = "eu01";
+export declare const ListVersionsRequestRegion: any;
+export interface ListVersionsRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ListVersionsRequestRegion | (string & {});
+}
+export declare const ListVersionsRequest: S.Schema<ListVersionsRequest>;
+/** The version of the sqlserver instance and more details. */
+export interface Version {
+    /** Flag if the version is a beta version. If set the version may contain bugs and is not fully tested. */
+    beta: boolean;
+    /** Timestamp in RFC3339 format which says when the version will no longer be supported by STACKIT. */
+    deprecated: string;
+    /** Flag if the version is recommend by the STACKIT Team. */
+    recommend: boolean;
+    /** The sqlserver version used for the instance. */
+    version: string;
+}
+export declare const Version: S.Schema<Version>;
+/** A list containing available sqlserver versions. */
+export type ListVersionsResponseVersionsList = Array<Version>;
+export declare const ListVersionsResponseVersionsList: S.Schema<ListVersionsResponseVersionsList>;
+export interface ListVersionsResponse {
+    /** A list containing available sqlserver versions. */
+    versions: ListVersionsResponseVersionsList;
+}
+export declare const ListVersionsResponse: S.Schema<ListVersionsResponse>;
+export type PartialUpdateInstanceRequestRegion = "eu01";
+export declare const PartialUpdateInstanceRequestRegion: any;
+/** the network configuration of the instance. */
+export interface PartialUpdateInstanceRequestNetwork {
+    acl?: Acl;
+}
+export declare const PartialUpdateInstanceRequestNetwork: S.Schema<PartialUpdateInstanceRequestNetwork>;
+/** The object containing information about the storage size and class. */
+export interface StorageUpdate {
+    size?: number;
+}
+export declare const StorageUpdate: S.Schema<StorageUpdate>;
+export type InstanceVersionOpt = "2022";
+export declare const InstanceVersionOpt: any;
+export interface PartialUpdateInstanceRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: PartialUpdateInstanceRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    backupSchedule?: string;
+    flavorId?: string;
+    labels?: Labels;
+    name?: string;
+    /** the network configuration of the instance. */
+    network?: PartialUpdateInstanceRequestNetwork;
+    retentionDays?: number;
+    storage?: StorageUpdate;
+    version?: InstanceVersionOpt | (string & {});
+}
+export declare const PartialUpdateInstanceRequest: S.Schema<PartialUpdateInstanceRequest>;
+export interface PartialUpdateInstanceResponse {
+}
+export declare const PartialUpdateInstanceResponse: S.Schema<PartialUpdateInstanceResponse>;
+export type ResetUserRequestRegion = "eu01";
+export declare const ResetUserRequestRegion: any;
+export interface ResetUserRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ResetUserRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    /** The ID of the user. */
+    userId: number;
+}
+export declare const ResetUserRequest: S.Schema<ResetUserRequest>;
+export interface ResetUserResponse {
+    password: string | Redacted.Redacted<string>;
+    status: string;
+    uri: string;
+    username: string;
+}
+export declare const ResetUserResponse: S.Schema<ResetUserResponse>;
+export type RestoreDatabaseFromBackupRequestRegion = "eu01";
+export declare const RestoreDatabaseFromBackupRequestRegion: any;
+export type SourceBackupType = "BACKUP";
+export declare const SourceBackupType: any;
+/** Restore from an existing managed backup. */
+export interface SourceBackup {
+    type: SourceBackupType;
+}
+export declare const SourceBackup: S.Schema<SourceBackup>;
+export interface S3fileInfo {
+    /** The sequence number of the file */
+    file_number?: number;
+    /** The path to the file on the S3 bucket */
+    file_path?: string;
+}
+export declare const S3fileInfo: S.Schema<S3fileInfo>;
+/** The backup files from which the database should be restored */
+export type ExternalS3S3FilesList = Array<S3fileInfo>;
+export declare const ExternalS3S3FilesList: S.Schema<ExternalS3S3FilesList>;
+/** The external S3 information */
+export interface ExternalS3 {
+    /** The s3 access key id */
+    s3_access_key: string;
+    /** The s3 access secret */
+    s3_access_secret: string | Redacted.Redacted<string>;
+    /** The s3 bucket address */
+    s3_bucket: string;
+    /** The backup files from which the database should be restored */
+    s3_files: ExternalS3S3FilesList;
+}
+export declare const ExternalS3: S.Schema<ExternalS3>;
+export type SourceExternalS3Type = "EXTERNAL_S3";
+export declare const SourceExternalS3Type: any;
+/** Restore from an external S3 backup file. */
+export interface SourceExternalS3 {
+    database_owner: string;
+    /** Logging guid to have a complete activity log over all sub stored procedures. */
+    logging_guid?: string;
+    s3_details: ExternalS3;
+    type: SourceExternalS3Type;
+}
+export declare const SourceExternalS3: S.Schema<SourceExternalS3>;
+/** The source of the restore. */
+export type RestoreDatabaseFromBackupRequestSource = SourceBackup | SourceExternalS3;
+export declare const RestoreDatabaseFromBackupRequestSource: S.Schema<RestoreDatabaseFromBackupRequestSource>;
+export interface RestoreDatabaseFromBackupRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: RestoreDatabaseFromBackupRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    /** The name of the database on the instance to be restore. */
+    database_name: string;
+    /** The source of the restore. */
+    source: RestoreDatabaseFromBackupRequestSource;
+}
+export declare const RestoreDatabaseFromBackupRequest: S.Schema<RestoreDatabaseFromBackupRequest>;
+export interface RestoreDatabaseFromBackupResponse {
+}
+export declare const RestoreDatabaseFromBackupResponse: S.Schema<RestoreDatabaseFromBackupResponse>;
+export type TriggerBackupRequestRegion = "eu01";
+export declare const TriggerBackupRequestRegion: any;
+export interface TriggerBackupRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: TriggerBackupRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    /** The name of the database. */
+    databaseName: string;
+}
+export declare const TriggerBackupRequest: S.Schema<TriggerBackupRequest>;
+export interface TriggerBackupResponse {
+}
+export declare const TriggerBackupResponse: S.Schema<TriggerBackupResponse>;
+export type TriggerRestoreRequestRegion = "eu01";
+export declare const TriggerRestoreRequestRegion: any;
+export interface TriggerRestoreRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: TriggerRestoreRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    /** The name of the database. */
+    databaseName: string;
+    name: string;
+    restoreDateTime: string;
+}
+export declare const TriggerRestoreRequest: S.Schema<TriggerRestoreRequest>;
+export interface TriggerRestoreResponse {
+}
+export declare const TriggerRestoreResponse: S.Schema<TriggerRestoreResponse>;
+export type UpdateInstanceRequestRegion = "eu01";
+export declare const UpdateInstanceRequestRegion: any;
+/** the network configuration of the instance. */
+export interface UpdateInstanceRequestNetwork {
+    acl: Acl;
+}
+export declare const UpdateInstanceRequestNetwork: S.Schema<UpdateInstanceRequestNetwork>;
+export interface UpdateInstanceRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: UpdateInstanceRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    backupSchedule: string;
+    flavorId: string;
+    labels?: Labels;
+    name: string;
+    /** the network configuration of the instance. */
+    network: UpdateInstanceRequestNetwork;
+    retentionDays: number;
+    storage: StorageUpdate;
+    version: InstanceVersion | (string & {});
+}
+export declare const UpdateInstanceRequest: S.Schema<UpdateInstanceRequest>;
+export interface UpdateInstanceResponse {
+}
+export declare const UpdateInstanceResponse: S.Schema<UpdateInstanceResponse>;
+export type UpdateInstanceProtectionRequestRegion = "eu01";
+export declare const UpdateInstanceProtectionRequestRegion: any;
+export interface UpdateInstanceProtectionRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: UpdateInstanceProtectionRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    isDeletable: boolean;
+}
+export declare const UpdateInstanceProtectionRequest: S.Schema<UpdateInstanceProtectionRequest>;
+export interface UpdateInstanceProtectionResponse {
+    isDeletable: boolean;
+}
+export declare const UpdateInstanceProtectionResponse: S.Schema<UpdateInstanceProtectionResponse>;
+export type CreateDatabaseError = BadRequest | Forbidden | NotFound | UnprocessableEntity | StackitOpError;
+/** Create Database Create database for a user. Note: The name of a valid user must be provided in the 'options' map field using the key 'owner' */
+export declare const createDatabase: API.OperationMethod<CreateDatabaseRequest, CreateDatabaseResponse, CreateDatabaseError, StackitOpContext>;
+export type CreateInstanceError = BadRequest | Forbidden | NotFound | UnprocessableEntity | StackitOpError;
+/** Create Instance Create a new instance of a sqlserver database instance. */
+export declare const createInstance: API.OperationMethod<CreateInstanceRequest, CreateInstanceResponse, CreateInstanceError, StackitOpContext>;
+export type CreateUserError = BadRequest | Forbidden | NotFound | UnprocessableEntity | StackitOpError;
+/** Create User Create user for an instance. */
+export declare const createUser: API.OperationMethod<CreateUserRequest, CreateUserResponse, CreateUserError, StackitOpContext>;
+export type DeleteDatabaseError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Delete Database Delete database for an instance. */
+export declare const deleteDatabase: API.OperationMethod<DeleteDatabaseRequest, DeleteDatabaseResponse, DeleteDatabaseError, StackitOpContext>;
+export type DeleteInstanceError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Delete Instance Delete an available sqlserver instance. */
+export declare const deleteInstance: API.OperationMethod<DeleteInstanceRequest, DeleteInstanceResponse, DeleteInstanceError, StackitOpContext>;
+export type DeleteUserError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Delete User Delete an user from a specific instance. */
+export declare const deleteUser: API.OperationMethod<DeleteUserRequest, DeleteUserResponse, DeleteUserError, StackitOpContext>;
+export type GetBackupError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Get specific backup Get information about a specific backup for an instance. */
+export declare const getBackup: API.OperationMethod<GetBackupRequest, GetBackupResponse, GetBackupError, StackitOpContext>;
+export type GetDatabaseError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Get Database Get specific available database */
+export declare const getDatabase: API.OperationMethod<GetDatabaseRequest, GetDatabaseResponse, GetDatabaseError, StackitOpContext>;
+export type GetInstanceError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Get Specific Instance Get information about a specific available instance */
+export declare const getInstance: API.OperationMethod<GetInstanceRequest, GetInstanceResponse, GetInstanceError, StackitOpContext>;
+export type GetUserError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Get User Get a specific available user for an instance. */
+export declare const getUser: API.OperationMethod<GetUserRequest, GetUserResponse, GetUserError, StackitOpContext>;
+export type ListBackupsError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** List backups List all backups which are available for a specific instance. */
+export declare const listBackups: API.OperationMethod<ListBackupsRequest, ListBackupResponse, ListBackupsError, StackitOpContext>;
+export type ListCollationsError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Get database collation list Returns a list of collations for an instance */
+export declare const listCollations: API.OperationMethod<ListCollationsRequest, ListCollationsResponse, ListCollationsError, StackitOpContext>;
+export type ListCompatibilitiesError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Get database compatibility list Returns a list of compatibility levels for creating a new database */
+export declare const listCompatibilities: API.OperationMethod<ListCompatibilitiesRequest, ListCompatibilityResponse, ListCompatibilitiesError, StackitOpContext>;
+export type ListCurrentRunningRestoreJobs2Error = BadRequest | Forbidden | NotFound | StackitOpError;
+/** List current running restore jobs List all currently running restore jobs which are available for a specific instance */
+export declare const listCurrentRunningRestoreJobs2: API.OperationMethod<ListCurrentRunningRestoreJobsRequest, ListCurrentRunningRestoreJobs, ListCurrentRunningRestoreJobs2Error, StackitOpContext>;
+export type ListDatabasesError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** List Databases List available databases for an instance. */
+export declare const listDatabases: API.OperationMethod<ListDatabasesRequest, ListDatabasesResponse, ListDatabasesError, StackitOpContext>;
+export type ListFlavors2Error = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Get Flavors Get all available flavors for a project. */
+export declare const listFlavors2: API.OperationMethod<ListFlavorsRequest, ListFlavorsResponse, ListFlavors2Error, StackitOpContext>;
+export type ListInstancesError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** List Instances List all available instances for your project. */
+export declare const listInstances: API.OperationMethod<ListInstancesRequest, ListInstancesResponse, ListInstancesError, StackitOpContext>;
+export type ListRolesError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** List Roles List available roles for an instance that can be assigned to a user */
+export declare const listRoles: API.OperationMethod<ListRolesRequest, ListRolesResponse, ListRolesError, StackitOpContext>;
+export type ListStoragesError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Get Storages Get available storages for a specific flavor */
+export declare const listStorages: API.OperationMethod<ListStoragesRequest, ListStoragesResponse, ListStoragesError, StackitOpContext>;
+export type ListUsersError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** List Users List available users for an instance. */
+export declare const listUsers: API.OperationMethod<ListUsersRequest, ListUserResponse, ListUsersError, StackitOpContext>;
+export type ListVersionsError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Get Versions Get the sqlserver available versions for the project. */
+export declare const listVersions: API.OperationMethod<ListVersionsRequest, ListVersionsResponse, ListVersionsError, StackitOpContext>;
+export type PartialUpdateInstanceError = BadRequest | Forbidden | NotFound | UnprocessableEntity | StackitOpError;
+/** Update Instance Partially Update an available instance of a mssql database. No fields are required. **Please note that any changes applied via PUT or PATCH requests will initiate a reboot of the SQL Server Flex Instance.** */
+export declare const partialUpdateInstance: API.OperationMethod<PartialUpdateInstanceRequest, PartialUpdateInstanceResponse, PartialUpdateInstanceError, StackitOpContext>;
+export type ResetUserError = BadRequest | Forbidden | NotFound | UnprocessableEntity | StackitOpError;
+/** Reset User Reset an user from an specific instance. */
+export declare const resetUser: API.OperationMethod<ResetUserRequest, ResetUserResponse, ResetUserError, StackitOpContext>;
+export type RestoreDatabaseFromBackupError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Create a Restore Operation Triggers a new restore operation for the specified instance. The request body defines the source (e.g., internal backup, external S3) and the target database. */
+export declare const restoreDatabaseFromBackup: API.OperationMethod<RestoreDatabaseFromBackupRequest, RestoreDatabaseFromBackupResponse, RestoreDatabaseFromBackupError, StackitOpContext>;
+export type TriggerBackupError = BadRequest | Forbidden | NotFound | UnprocessableEntity | StackitOpError;
+/** Trigger backup for a specific Database Trigger backup for a specific database */
+export declare const triggerBackup: API.OperationMethod<TriggerBackupRequest, TriggerBackupResponse, TriggerBackupError, StackitOpContext>;
+export type TriggerRestoreError = BadRequest | Forbidden | NotFound | UnprocessableEntity | StackitOpError;
+/** Trigger restore for a specific Database Trigger restore for a specific Database */
+export declare const triggerRestore: API.OperationMethod<TriggerRestoreRequest, TriggerRestoreResponse, TriggerRestoreError, StackitOpContext>;
+export type UpdateInstanceError = BadRequest | Forbidden | NotFound | UnprocessableEntity | StackitOpError;
+/** Update Instance Updates an available instance of a sqlserver database **Please note that any changes applied via PUT or PATCH requests will initiate a reboot of the SQL Server Flex Instance.** */
+export declare const updateInstance: API.OperationMethod<UpdateInstanceRequest, UpdateInstanceResponse, UpdateInstanceError, StackitOpContext>;
+export type UpdateInstanceProtectionError = BadRequest | Forbidden | NotFound | UnprocessableEntity | StackitOpError;
+/** Protect Instance Toggle the deletion protection for an instance. */
+export declare const updateInstanceProtection: API.OperationMethod<UpdateInstanceProtectionRequest, UpdateInstanceProtectionResponse, UpdateInstanceProtectionError, StackitOpContext>;
+//# sourceMappingURL=sqlserverflex.d.ts.map