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

package/lib/services/postgres_flex.d.ts

@@ -0,0 +1,854 @@
+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 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 CloneInstanceRequestRegion = "eu01" | "eu02";
+export declare const CloneInstanceRequestRegion: any;
+export interface CloneInstanceOverrides {
+    class: string;
+    name?: string;
+    size: number;
+}
+export declare const CloneInstanceOverrides: S.Schema<CloneInstanceOverrides>;
+export interface CloneInstanceRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: CloneInstanceRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    instanceOverrides: CloneInstanceOverrides;
+    pointInTime: string;
+}
+export declare const CloneInstanceRequest: S.Schema<CloneInstanceRequest>;
+export interface CloneInstanceResponse {
+    id: string;
+}
+export declare const CloneInstanceResponse: S.Schema<CloneInstanceResponse>;
+export type CreateDatabaseRequestRegion = "eu01" | "eu02";
+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;
+    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" | "eu02";
+export declare const CreateInstanceRequestRegion: any;
+/** The configuration for instance's volume and backup storage encryption. ⚠️ **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 interface InstanceEncryption {
+    /** The encryption-key key identifier */
+    kekKeyId: string;
+    /** The encryption-key keyring identifier */
+    kekKeyRingId: string;
+    /** The encryption-key version */
+    kekKeyVersion: string;
+    serviceAccount: string;
+}
+export declare const InstanceEncryption: S.Schema<InstanceEncryption>;
+/** Key-value pairs, 63 characters max, begin and end with an alphanumerical character, may contain dashes (-), underscores (_), dots (.), and alphanumerics between. Key MUST be at least 1 character. Max 64 labels Regex for keys: ^(?=.{1,63}$)([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9]$ Regex for values: ^(?=.{0,63}$)(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])*$ The stackit- prefix is reserved and cannot be used for Keys. */
+export type Labels = {
+    [key: string]: string | null | undefined;
+};
+export declare const Labels: S.Schema<Labels>;
+/** The access scope of the instance. It defines if the instance is public or airgapped. ⚠️ **Note:** "SNA" value for the "network.accessScope" field 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 access configuration of the instance */
+export interface InstanceNetworkCreate {
+    accessScope?: InstanceNetworkAccessScope | (string & {});
+    acl: Acl;
+}
+export declare const InstanceNetworkCreate: S.Schema<InstanceNetworkCreate>;
+/** The object containing information about the storage size and class. */
+export interface StorageCreate {
+    class: string;
+    size: number;
+}
+export declare const StorageCreate: S.Schema<StorageCreate>;
+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;
+    network: InstanceNetworkCreate;
+    retentionDays: number | null;
+    storage: StorageCreate;
+    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;
+/** A list containing the user roles for the instance. Please refer to the List Roles endpoint for a list of all available Roles. */
+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;
+    name: string;
+    /** A list containing the user roles for the instance. Please refer to the List Roles endpoint for a list of all available Roles. */
+    roles?: CreateUserRequestRolesList;
+}
+export declare const CreateUserRequest: S.Schema<CreateUserRequest>;
+export interface CreateUserResponse {
+    id: number;
+    name: string;
+    password: string | Redacted.Redacted<string>;
+    state: string;
+}
+export declare const CreateUserResponse: S.Schema<CreateUserResponse>;
+export type DeleteDatabaseRequestRegion = "eu01" | "eu02";
+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 ID of the database. */
+    databaseId: number;
+}
+export declare const DeleteDatabaseRequest: S.Schema<DeleteDatabaseRequest>;
+export interface DeleteDatabaseResponse {
+}
+export declare const DeleteDatabaseResponse: S.Schema<DeleteDatabaseResponse>;
+export type DeleteInstanceRequestRegion = "eu01" | "eu02";
+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" | "eu02";
+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" | "eu02";
+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 BackupData {
+    completionTime: string;
+    id: number;
+    name: string;
+    retainedUntil: string;
+    size: number;
+    type: string;
+}
+export declare const BackupData: S.Schema<BackupData>;
+export type GetDatabaseRequestRegion = "eu01" | "eu02";
+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 ID of the database. */
+    databaseId: number;
+}
+export declare const GetDatabaseRequest: S.Schema<GetDatabaseRequest>;
+export interface GetDatabaseResponse {
+    id: number;
+    name: string;
+    owner: string;
+}
+export declare const GetDatabaseResponse: S.Schema<GetDatabaseResponse>;
+export type GetInstanceRequestRegion = "eu01" | "eu02";
+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>;
+/** The DNS name and port in the instance overview */
+export interface InstanceConnectionInfoWrite {
+    /** The host of the instance. */
+    host: string;
+    /** The port of the instance. */
+    port: number;
+}
+export declare const InstanceConnectionInfoWrite: S.Schema<InstanceConnectionInfoWrite>;
+/** The connection information of the instance */
+export interface InstanceConnectionInfo {
+    write: InstanceConnectionInfoWrite;
+}
+export declare const InstanceConnectionInfo: S.Schema<InstanceConnectionInfo>;
+/** The access configuration of the instance */
+export interface InstanceNetwork {
+    accessScope?: InstanceNetworkAccessScope;
+    acl: Acl;
+    instanceAddress?: string;
+    routerAddress?: string;
+}
+export declare const InstanceNetwork: S.Schema<InstanceNetwork>;
+/** The current state of the instance. */
+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;
+    connectionInfo: InstanceConnectionInfo;
+    encryption?: InstanceEncryption;
+    flavorId: string;
+    id: string;
+    isDeletable: boolean;
+    labels?: Labels;
+    name: string;
+    network: InstanceNetwork;
+    retentionDays: number | null;
+    state: State;
+    storage: Storage;
+    version: string;
+}
+export declare const GetInstanceResponse: S.Schema<GetInstanceResponse>;
+export type GetUserRequestRegion = "eu01" | "eu02";
+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 {
+    id: number;
+    name: string;
+    /** A list of user roles. */
+    roles: GetUserResponseRolesList;
+    state: string;
+}
+export declare const GetUserResponse: S.Schema<GetUserResponse>;
+export type ListBackupsRequestRegion = "eu01" | "eu02";
+export declare const ListBackupsRequestRegion: any;
+export type BackupSort = "completion_time.desc" | "completion_time.asc" | "end_time.desc" | "end_time.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>;
+/** The list containing the information about the backups. */
+export type ListBackupsResponseBackupsList = Array<BackupData>;
+export declare const ListBackupsResponseBackupsList: S.Schema<ListBackupsResponseBackupsList>;
+export interface Pagination {
+    page: number;
+    size: number;
+    sort: string;
+    totalPages: number;
+    totalRows: number;
+}
+export declare const Pagination: S.Schema<Pagination>;
+export interface ListBackupsResponse {
+    /** The list containing the information about the backups. */
+    backups: ListBackupsResponseBackupsList;
+    pagination: Pagination;
+}
+export declare const ListBackupsResponse: S.Schema<ListBackupsResponse>;
+export type ListCollationsRequestRegion = "eu01" | "eu02";
+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>;
+/** List of collations available for the instance. */
+export type ListCollationsResponseCollationsList = Array<string>;
+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 ListDatabasesRequestRegion = "eu01" | "eu02";
+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";
+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 {
+    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" | "eu02";
+export declare const ListFlavorsRequestRegion: any;
+export type FlavorSort = "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" | "eu02";
+export declare const ListInstancesRequestRegion: any;
+export type InstanceSort = "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 state. */
+export type ListInstancesResponseInstancesList = Array<ListInstance>;
+export declare const ListInstancesResponseInstancesList: S.Schema<ListInstancesResponseInstancesList>;
+export interface ListInstancesResponse {
+    /** List of owned instances and their current state. */
+    instances: ListInstancesResponseInstancesList;
+    pagination: Pagination;
+}
+export declare const ListInstancesResponse: S.Schema<ListInstancesResponse>;
+export type ListRolesRequestRegion = "eu01" | "eu02";
+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 all role names available in the instance */
+export type ListRolesResponseRolesList = Array<string>;
+export declare const ListRolesResponseRolesList: S.Schema<ListRolesResponseRolesList>;
+export interface ListRolesResponse {
+    /** List of all role names available in the instance */
+    roles: ListRolesResponseRolesList;
+}
+export declare const ListRolesResponse: S.Schema<ListRolesResponse>;
+export type ListUsersRequestRegion = "eu01" | "eu02";
+export declare const ListUsersRequestRegion: any;
+export type UserSort = "id.asc" | "id.desc" | "name.desc" | "name.asc" | "state.desc" | "state.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;
+    name: string;
+    state: string;
+}
+export declare const ListUser: S.Schema<ListUser>;
+/** List of all users inside an instance */
+export type ListUsersResponseUsersList = Array<ListUser>;
+export declare const ListUsersResponseUsersList: S.Schema<ListUsersResponseUsersList>;
+export interface ListUsersResponse {
+    pagination: Pagination;
+    /** List of all users inside an instance */
+    users: ListUsersResponseUsersList;
+}
+export declare const ListUsersResponse: S.Schema<ListUsersResponse>;
+export type ListVersionsRequestRegion = "eu01" | "eu02";
+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 postgres 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 postgres version used for the instance. */
+    version: string;
+}
+export declare const Version: S.Schema<Version>;
+/** A list containing available postgres versions. */
+export type ListVersionsResponseVersionsList = Array<Version>;
+export declare const ListVersionsResponseVersionsList: S.Schema<ListVersionsResponseVersionsList>;
+export interface ListVersionsResponse {
+    /** A list containing available postgres versions. */
+    versions: ListVersionsResponseVersionsList;
+}
+export declare const ListVersionsResponse: S.Schema<ListVersionsResponse>;
+export type PartialUpdateDatabaseRequestRegion = "eu01" | "eu02";
+export declare const PartialUpdateDatabaseRequestRegion: any;
+export interface PartialUpdateDatabaseRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: PartialUpdateDatabaseRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    /** The ID of the database. */
+    databaseId: number;
+    name?: string;
+    owner?: string;
+}
+export declare const PartialUpdateDatabaseRequest: S.Schema<PartialUpdateDatabaseRequest>;
+export interface PartialUpdateDatabaseResponse {
+}
+export declare const PartialUpdateDatabaseResponse: S.Schema<PartialUpdateDatabaseResponse>;
+export type PartialUpdateInstanceRequestRegion = "eu01" | "eu02";
+export declare const PartialUpdateInstanceRequestRegion: any;
+/** List of IPV4 cidr. */
+export type AclOpt = Array<string>;
+export declare const AclOpt: S.Schema<AclOpt>;
+/** The access configuration of the instance */
+export interface InstanceNetworkOpt {
+    acl?: AclOpt;
+}
+export declare const InstanceNetworkOpt: S.Schema<InstanceNetworkOpt>;
+/** The object containing information about the storage size and class. */
+export interface StorageUpdate {
+    size?: number;
+}
+export declare const StorageUpdate: S.Schema<StorageUpdate>;
+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;
+    network?: InstanceNetworkOpt;
+    retentionDays?: number;
+    storage?: StorageUpdate;
+    version?: string;
+}
+export declare const PartialUpdateInstanceRequest: S.Schema<PartialUpdateInstanceRequest>;
+export interface PartialUpdateInstanceResponse {
+}
+export declare const PartialUpdateInstanceResponse: S.Schema<PartialUpdateInstanceResponse>;
+export type PartialUpdateUserRequestRegion = "eu01" | "eu02";
+export declare const PartialUpdateUserRequestRegion: any;
+/** A list containing the user roles for the instance. Please refer to the List Roles endpoint for a list of all available Roles. */
+export type PartialUpdateUserRequestRolesList = Array<string>;
+export declare const PartialUpdateUserRequestRolesList: S.Schema<PartialUpdateUserRequestRolesList>;
+export interface PartialUpdateUserRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: PartialUpdateUserRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    /** The ID of the user. */
+    userId: number;
+    name?: string;
+    /** A list containing the user roles for the instance. Please refer to the List Roles endpoint for a list of all available Roles. */
+    roles?: PartialUpdateUserRequestRolesList;
+}
+export declare const PartialUpdateUserRequest: S.Schema<PartialUpdateUserRequest>;
+export interface PartialUpdateUserResponse {
+}
+export declare const PartialUpdateUserResponse: S.Schema<PartialUpdateUserResponse>;
+export type ResetUserPasswordRequestRegion = "eu01" | "eu02";
+export declare const ResetUserPasswordRequestRegion: any;
+export interface ResetUserPasswordRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: ResetUserPasswordRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    /** The ID of the user. */
+    userId: number;
+}
+export declare const ResetUserPasswordRequest: S.Schema<ResetUserPasswordRequest>;
+export interface ResetUserPasswordResponse {
+    name: string;
+    password: string | Redacted.Redacted<string>;
+    state: string;
+}
+export declare const ResetUserPasswordResponse: S.Schema<ResetUserPasswordResponse>;
+export type UpdateDatabaseRequestRegion = "eu01" | "eu02";
+export declare const UpdateDatabaseRequestRegion: any;
+export interface UpdateDatabaseRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: UpdateDatabaseRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    /** The ID of the database. */
+    databaseId: number;
+    name: string;
+    owner: string;
+}
+export declare const UpdateDatabaseRequest: S.Schema<UpdateDatabaseRequest>;
+export interface UpdateDatabaseResponse {
+}
+export declare const UpdateDatabaseResponse: S.Schema<UpdateDatabaseResponse>;
+export type UpdateInstanceRequestRegion = "eu01" | "eu02";
+export declare const UpdateInstanceRequestRegion: any;
+/** The access configuration of the instance */
+export interface InstanceNetworkUpdate {
+    acl: Acl;
+}
+export declare const InstanceNetworkUpdate: S.Schema<InstanceNetworkUpdate>;
+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;
+    network: InstanceNetworkUpdate;
+    retentionDays: number | null;
+    storage: StorageUpdate;
+    version: string;
+}
+export declare const UpdateInstanceRequest: S.Schema<UpdateInstanceRequest>;
+export interface UpdateInstanceResponse {
+}
+export declare const UpdateInstanceResponse: S.Schema<UpdateInstanceResponse>;
+export type UpdateInstanceProtectionRequestRegion = "eu01" | "eu02";
+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 UpdateUserRequestRegion = "eu01" | "eu02";
+export declare const UpdateUserRequestRegion: any;
+/** A list containing the user roles for the instance. Please refer to the List Roles endpoint for a list of all available Roles. */
+export type UpdateUserRequestRolesList = Array<string>;
+export declare const UpdateUserRequestRolesList: S.Schema<UpdateUserRequestRolesList>;
+export interface UpdateUserRequest {
+    /** The STACKIT project ID. */
+    projectId: string;
+    /** The region which should be addressed */
+    region: UpdateUserRequestRegion | (string & {});
+    /** The ID of the instance. */
+    instanceId: string;
+    /** The ID of the user. */
+    userId: number;
+    name?: string;
+    /** A list containing the user roles for the instance. Please refer to the List Roles endpoint for a list of all available Roles. */
+    roles: UpdateUserRequestRolesList;
+}
+export declare const UpdateUserRequest: S.Schema<UpdateUserRequest>;
+export interface UpdateUserResponse {
+}
+export declare const UpdateUserResponse: S.Schema<UpdateUserResponse>;
+export type CloneInstanceError = BadRequest | Forbidden | NotFound | Conflict | UnprocessableEntity | StackitOpError;
+/** Clone Instance Clone Instance */
+export declare const cloneInstance: API.OperationMethod<CloneInstanceRequest, CloneInstanceResponse, CloneInstanceError, StackitOpContext>;
+export type CreateDatabaseError = BadRequest | Forbidden | NotFound | Conflict | 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 postgres database instance. */
+export declare const createInstance: API.OperationMethod<CreateInstanceRequest, CreateInstanceResponse, CreateInstanceError, StackitOpContext>;
+export type CreateUserError = BadRequest | Forbidden | NotFound | Conflict | 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 postgres instance. */
+export declare const deleteInstance: API.OperationMethod<DeleteInstanceRequest, DeleteInstanceResponse, DeleteInstanceError, StackitOpContext>;
+export type DeleteUserError = BadRequest | Forbidden | NotFound | Conflict | 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, BackupData, GetBackupError, StackitOpContext>;
+export type GetDatabaseError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Get Specific Database Get information about a specific database in an instance. */
+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, ListBackupsResponse, ListBackupsError, StackitOpContext>;
+export type ListCollationsError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Get Collations for an Instance Get available collations for an instance */
+export declare const listCollations: API.OperationMethod<ListCollationsRequest, ListCollationsResponse, ListCollationsError, 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. */
+export declare const listRoles: API.OperationMethod<ListRolesRequest, ListRolesResponse, ListRolesError, StackitOpContext>;
+export type ListUsersError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** List Users List available users for an instance. */
+export declare const listUsers: API.OperationMethod<ListUsersRequest, ListUsersResponse, ListUsersError, StackitOpContext>;
+export type ListVersionsError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Get Versions Get available postgres versions for the project. */
+export declare const listVersions: API.OperationMethod<ListVersionsRequest, ListVersionsResponse, ListVersionsError, StackitOpContext>;
+export type PartialUpdateDatabaseError = BadRequest | Forbidden | NotFound | UnprocessableEntity | StackitOpError;
+/** Update Database partially Update a database partially in an instance. */
+export declare const partialUpdateDatabase: API.OperationMethod<PartialUpdateDatabaseRequest, PartialUpdateDatabaseResponse, PartialUpdateDatabaseError, StackitOpContext>;
+export type PartialUpdateInstanceError = BadRequest | Forbidden | NotFound | UnprocessableEntity | StackitOpError;
+/** Update Instance Partially Update an available instance of a postgres database. No fields are required. */
+export declare const partialUpdateInstance: API.OperationMethod<PartialUpdateInstanceRequest, PartialUpdateInstanceResponse, PartialUpdateInstanceError, StackitOpContext>;
+export type PartialUpdateUserError = BadRequest | Forbidden | NotFound | UnprocessableEntity | StackitOpError;
+/** Update User Partially Update an user partially for an instance. */
+export declare const partialUpdateUser: API.OperationMethod<PartialUpdateUserRequest, PartialUpdateUserResponse, PartialUpdateUserError, StackitOpContext>;
+export type ResetUserPasswordError = BadRequest | Forbidden | NotFound | UnprocessableEntity | StackitOpError;
+/** Reset User Reset an user from an specific instance. */
+export declare const resetUserPassword: API.OperationMethod<ResetUserPasswordRequest, ResetUserPasswordResponse, ResetUserPasswordError, StackitOpContext>;
+export type UpdateDatabaseError = BadRequest | Forbidden | NotFound | UnprocessableEntity | StackitOpError;
+/** Update Database Update a database in an instance. */
+export declare const updateDatabase: API.OperationMethod<UpdateDatabaseRequest, UpdateDatabaseResponse, UpdateDatabaseError, StackitOpContext>;
+export type UpdateInstanceError = BadRequest | Forbidden | NotFound | UnprocessableEntity | StackitOpError;
+/** Update Instance Updates an available instance of a postgres database */
+export declare const updateInstance: API.OperationMethod<UpdateInstanceRequest, UpdateInstanceResponse, UpdateInstanceError, StackitOpContext>;
+export type UpdateInstanceProtectionError = BadRequest | Forbidden | NotFound | UnprocessableEntity | StackitOpError;
+/** Toggle Instance Protection Toggle the deletion protection for an instance. */
+export declare const updateInstanceProtection: API.OperationMethod<UpdateInstanceProtectionRequest, UpdateInstanceProtectionResponse, UpdateInstanceProtectionError, StackitOpContext>;
+export type UpdateUserError = BadRequest | Forbidden | NotFound | UnprocessableEntity | StackitOpError;
+/** Update User Update user for an instance. */
+export declare const updateUser: API.OperationMethod<UpdateUserRequest, UpdateUserResponse, UpdateUserError, StackitOpContext>;
+//# sourceMappingURL=postgres_flex.d.ts.map