@distilled.cloud/ovh 0.0.0 → 1.0.0-rc.9

package/lib/services/hostingprivatedatabase.d.ts

@@ -0,0 +1,1402 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as Redacted from "effect/Redacted";
+import * as API from "@distilled.cloud/core/api";
+import { type OvhOpError, type OvhOpContext } from "../protocol.ts";
+export type { OvhOpError, OvhOpContext };
+/** All future uses you can provide for a service termination */
+export type ServiceTerminationFutureUseEnum = "NOT_REPLACING_SERVICE" | "OTHER" | "SUBSCRIBE_AN_OTHER_SERVICE" | "SUBSCRIBE_OTHER_KIND_OF_SERVICE_WITH_COMPETITOR" | "SUBSCRIBE_SIMILAR_SERVICE_WITH_COMPETITOR";
+export declare const ServiceTerminationFutureUseEnum: any;
+/** All reasons you can provide for a service termination */
+export type ServiceTerminationReasonEnum = "FEATURES_DONT_SUIT_ME" | "LACK_OF_PERFORMANCES" | "MIGRATED_TO_ANOTHER_OVH_PRODUCT" | "MIGRATED_TO_COMPETITOR" | "NOT_ENOUGH_RECOGNITION" | "NOT_NEEDED_ANYMORE" | "NOT_RELIABLE" | "NO_ANSWER" | "OTHER" | "PRODUCT_DIMENSION_DONT_SUIT_ME" | "PRODUCT_TOOLS_DONT_SUIT_ME" | "TOO_EXPENSIVE" | "TOO_HARD_TO_USE" | "UNSATIFIED_BY_CUSTOMER_SUPPORT";
+export declare const ServiceTerminationReasonEnum: any;
+export interface ConfirmHostingPrivateDatabaseTerminationRequest {
+    /** Service name */
+    serviceName: string;
+    /** Commentary about your termination request */
+    commentary?: string;
+    /** All future uses you can provide for a service termination */
+    futureUse?: ServiceTerminationFutureUseEnum | (string & {});
+    /** All reasons you can provide for a service termination */
+    reason?: ServiceTerminationReasonEnum | (string & {});
+    /** The termination token sent by email to the admin contact */
+    token: string;
+}
+export declare const ConfirmHostingPrivateDatabaseTerminationRequest: S.Schema<ConfirmHostingPrivateDatabaseTerminationRequest>;
+export type ConfirmHostingPrivateDatabaseTerminationResponse = string;
+export declare const ConfirmHostingPrivateDatabaseTerminationResponse: S.Schema<ConfirmHostingPrivateDatabaseTerminationResponse>;
+export interface CopyHostingPrivateDatabaseDatabaseRequest {
+    /** Service name */
+    serviceName: string;
+    /** Database name */
+    databaseName: string;
+}
+export declare const CopyHostingPrivateDatabaseDatabaseRequest: S.Schema<CopyHostingPrivateDatabaseDatabaseRequest>;
+/** Database copy status */
+export type HostingPrivateDatabaseDatabaseCopyStatusEnum = "doing" | "done" | "error" | "todo";
+export declare const HostingPrivateDatabaseDatabaseCopyStatusEnum: any;
+/** Database copy */
+export interface HostingPrivateDatabaseDatabaseCopy {
+    /** Creation date of the database copy */
+    creationDate?: string;
+    /** Expiration date of the database copy */
+    expirationDate?: string | null;
+    /** Database copy ID */
+    id?: string;
+    /** Last update of the database copy */
+    lastUpdate?: string;
+    /** Database copy status */
+    status?: HostingPrivateDatabaseDatabaseCopyStatusEnum;
+}
+export declare const HostingPrivateDatabaseDatabaseCopy: S.Schema<HostingPrivateDatabaseDatabaseCopy>;
+export interface CopyHostingPrivateDatabaseDatabaseRestoreRequest {
+    /** Service name */
+    serviceName: string;
+    /** Database name */
+    databaseName: string;
+    /** Copy ID */
+    copyId: string;
+    /** Whether to flush the database before restoring the copy (default to false) */
+    flushDatabase?: boolean;
+}
+export declare const CopyHostingPrivateDatabaseDatabaseRestoreRequest: S.Schema<CopyHostingPrivateDatabaseDatabaseRestoreRequest>;
+/** Task's dunction */
+export type HostingPrivateDatabaseTaskFunctionEnum = "abuse" | "changeFtpPassword" | "changeRam" | "changeVersion" | "configuration/update" | "create" | "database/copy" | "database/copyRestore" | "database/create" | "database/delete" | "database/dump" | "database/dump/delete" | "database/extension/create" | "database/extension/delete" | "database/import" | "database/restore" | "database/wizard" | "delete" | "grant/create" | "grant/delete" | "grant/update" | "install" | "overquota/in" | "overquota/out" | "quotaRefresh" | "refresh" | "reopen" | "restart" | "start" | "stop" | "suspend" | "user/changePassword" | "user/create" | "user/delete" | "webhostingNetwork/disable" | "webhostingNetwork/enable" | "whitelist/create" | "whitelist/delete" | "whitelist/update";
+export declare const HostingPrivateDatabaseTaskFunctionEnum: any;
+/** Task's status */
+export type HostingPrivateDatabaseTaskStatusEnum = "cancelled" | "doing" | "done" | "error" | "todo";
+export declare const HostingPrivateDatabaseTaskStatusEnum: any;
+/** Web Cloud Database task */
+export interface HostingPrivateDatabaseTask {
+    /** Database name on which the task is working */
+    databaseName?: string | null;
+    /** Completion date */
+    doneDate?: string | null;
+    /** DumpId on which the task is working */
+    dumpId?: number | null;
+    /** Function name */
+    function?: HostingPrivateDatabaseTaskFunctionEnum;
+    /** The id of the task */
+    id?: number;
+    /** Last update */
+    lastUpdate?: string | null;
+    /** Task creation date */
+    startDate?: string;
+    /** Task status */
+    status?: HostingPrivateDatabaseTaskStatusEnum;
+    /** User name on which the task is working */
+    userName?: string | null;
+}
+export declare const HostingPrivateDatabaseTask: S.Schema<HostingPrivateDatabaseTask>;
+export interface CreateHostingPrivateDatabaseChangeContactRequest {
+    /** Service name */
+    serviceName: string;
+    /** The contact to set as admin contact */
+    contactAdmin?: string;
+    /** The contact to set as billing contact */
+    contactBilling?: string;
+    /** The contact to set as tech contact */
+    contactTech?: string;
+}
+export declare const CreateHostingPrivateDatabaseChangeContactRequest: S.Schema<CreateHostingPrivateDatabaseChangeContactRequest>;
+export type CreateHostingPrivateDatabaseChangeContactResponseBodyList = Array<number>;
+export declare const CreateHostingPrivateDatabaseChangeContactResponseBodyList: S.Schema<CreateHostingPrivateDatabaseChangeContactResponseBodyList>;
+export type CreateHostingPrivateDatabaseChangeContactResponse = CreateHostingPrivateDatabaseChangeContactResponseBodyList;
+export declare const CreateHostingPrivateDatabaseChangeContactResponse: S.Schema<CreateHostingPrivateDatabaseChangeContactResponse>;
+export interface CreateHostingPrivateDatabaseChangeFtpPasswordRequest {
+    /** Service name */
+    serviceName: string;
+    /** New ftp admin password (alphanumeric and 8 characters minimum) */
+    password: string | Redacted.Redacted<string>;
+}
+export declare const CreateHostingPrivateDatabaseChangeFtpPasswordRequest: S.Schema<CreateHostingPrivateDatabaseChangeFtpPasswordRequest>;
+/** Private database available version */
+export type HostingPrivateDatabaseAvailableVersionEnum = "mariadb_10.11" | "mariadb_10.5" | "mariadb_10.6" | "mariadb_11.4" | "mysql_8.0" | "mysql_8.4" | "postgresql_13" | "postgresql_14" | "postgresql_15" | "postgresql_16" | "postgresql_17" | "redis_7.0" | "valkey_7.2";
+export declare const HostingPrivateDatabaseAvailableVersionEnum: any;
+export interface CreateHostingPrivateDatabaseChangeVersionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Change the private database engine version */
+    version: HostingPrivateDatabaseAvailableVersionEnum | (string & {});
+}
+export declare const CreateHostingPrivateDatabaseChangeVersionRequest: S.Schema<CreateHostingPrivateDatabaseChangeVersionRequest>;
+export interface CreateHostingPrivateDatabaseDatabaseRequest {
+    /** Service name */
+    serviceName: string;
+    /** Name of your new database */
+    databaseName: string;
+}
+export declare const CreateHostingPrivateDatabaseDatabaseRequest: S.Schema<CreateHostingPrivateDatabaseDatabaseRequest>;
+export interface CreateHostingPrivateDatabaseDatabaseDumpRequest {
+    /** Service name */
+    serviceName: string;
+    /** Database name */
+    databaseName: string;
+    /** Whether to receive an email when the import is complete (default to false) */
+    sendEmail?: boolean;
+}
+export declare const CreateHostingPrivateDatabaseDatabaseDumpRequest: S.Schema<CreateHostingPrivateDatabaseDatabaseDumpRequest>;
+/** Grant on a database for a specific user */
+export type HostingPrivateDatabaseGrantGrantEnum = "admin" | "none" | "ro" | "rw";
+export declare const HostingPrivateDatabaseGrantGrantEnum: any;
+export interface CreateHostingPrivateDatabaseDatabaseWizardRequest {
+    /** Service name */
+    serviceName: string;
+    /** Name of your new database */
+    databaseName: string;
+    /** Grant of the user on this database */
+    grant: HostingPrivateDatabaseGrantGrantEnum | (string & {});
+    /** Password for the new user (alphanumeric and 8 characters minimum) */
+    password: string | Redacted.Redacted<string>;
+    /** New user name used to connect on your database */
+    userName: string;
+}
+export declare const CreateHostingPrivateDatabaseDatabaseWizardRequest: S.Schema<CreateHostingPrivateDatabaseDatabaseWizardRequest>;
+export interface CreateHostingPrivateDatabaseLogSubscriptionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Log kind name to subscribe to */
+    kind: string;
+    /** Customer log stream ID */
+    streamId: string;
+}
+export declare const CreateHostingPrivateDatabaseLogSubscriptionRequest: S.Schema<CreateHostingPrivateDatabaseLogSubscriptionRequest>;
+/** Asynchronous operation after subscribing or unsubscribing to a resource logs */
+export interface DbaasLogsLogSubscriptionResponse {
+    /** Identifier of the operation */
+    operationId?: string;
+    /** Operation owner's service name */
+    serviceName?: string;
+}
+export declare const DbaasLogsLogSubscriptionResponse: S.Schema<DbaasLogsLogSubscriptionResponse>;
+export interface CreateHostingPrivateDatabaseLogUrlRequest {
+    /** Service name */
+    serviceName: string;
+    /** Log kind name */
+    kind: string;
+}
+export declare const CreateHostingPrivateDatabaseLogUrlRequest: S.Schema<CreateHostingPrivateDatabaseLogUrlRequest>;
+/** Temporary url information */
+export interface DbaasLogsTemporaryLogsLink {
+    /** Temporary url expiration date */
+    expirationDate?: string;
+    /** Temporary url */
+    url?: string;
+}
+export declare const DbaasLogsTemporaryLogsLink: S.Schema<DbaasLogsTemporaryLogsLink>;
+export interface CreateHostingPrivateDatabaseQuotaRefreshRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const CreateHostingPrivateDatabaseQuotaRefreshRequest: S.Schema<CreateHostingPrivateDatabaseQuotaRefreshRequest>;
+export interface CreateHostingPrivateDatabaseUserRequest {
+    /** Service name */
+    serviceName: string;
+    /** Password for the new user ( alphanumeric and 8 characters minimum ) */
+    password: string | Redacted.Redacted<string>;
+    /** User name used to connect on your databases */
+    userName: string;
+}
+export declare const CreateHostingPrivateDatabaseUserRequest: S.Schema<CreateHostingPrivateDatabaseUserRequest>;
+export interface CreateHostingPrivateDatabaseUserChangePasswordRequest {
+    /** Service name */
+    serviceName: string;
+    /** User name */
+    userName: string;
+    /** Password for the new user ( alphanumeric and 8 characters minimum ) */
+    password: string | Redacted.Redacted<string>;
+}
+export declare const CreateHostingPrivateDatabaseUserChangePasswordRequest: S.Schema<CreateHostingPrivateDatabaseUserChangePasswordRequest>;
+export interface CreateHostingPrivateDatabaseUserGrantRequest {
+    /** Service name */
+    serviceName: string;
+    /** User name */
+    userName: string;
+    /** Database name where add grant */
+    databaseName: string;
+    /** Grant on a database for a specific user */
+    grant: HostingPrivateDatabaseGrantGrantEnum | (string & {});
+}
+export declare const CreateHostingPrivateDatabaseUserGrantRequest: S.Schema<CreateHostingPrivateDatabaseUserGrantRequest>;
+export interface CreateHostingPrivateDatabaseWebhostingNetworkRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const CreateHostingPrivateDatabaseWebhostingNetworkRequest: S.Schema<CreateHostingPrivateDatabaseWebhostingNetworkRequest>;
+export interface CreateHostingPrivateDatabaseWhitelistRequest {
+    /** Service name */
+    serviceName: string;
+    /** The whitelisted IP in your Web Cloud Database */
+    ip: string;
+    /** Custom name for your Whitelisted IP */
+    name?: string | null;
+    /** Authorize this IP to access service port */
+    service?: boolean;
+    /** Authorize this IP to access sftp port */
+    sftp?: boolean;
+}
+export declare const CreateHostingPrivateDatabaseWhitelistRequest: S.Schema<CreateHostingPrivateDatabaseWhitelistRequest>;
+export interface DeleteHostingPrivateDatabaseDatabaseRequest {
+    /** Service name */
+    serviceName: string;
+    /** Database name */
+    databaseName: string;
+}
+export declare const DeleteHostingPrivateDatabaseDatabaseRequest: S.Schema<DeleteHostingPrivateDatabaseDatabaseRequest>;
+export interface DeleteHostingPrivateDatabaseDatabaseCopyRequest {
+    /** Service name */
+    serviceName: string;
+    /** Database name */
+    databaseName: string;
+    /** Id */
+    id: string;
+}
+export declare const DeleteHostingPrivateDatabaseDatabaseCopyRequest: S.Schema<DeleteHostingPrivateDatabaseDatabaseCopyRequest>;
+export interface DeleteHostingPrivateDatabaseDatabaseCopyResponse {
+}
+export declare const DeleteHostingPrivateDatabaseDatabaseCopyResponse: S.Schema<DeleteHostingPrivateDatabaseDatabaseCopyResponse>;
+export interface DeleteHostingPrivateDatabaseDatabaseDumpRequest {
+    /** Service name */
+    serviceName: string;
+    /** Database name */
+    databaseName: string;
+    /** Id */
+    id: number;
+}
+export declare const DeleteHostingPrivateDatabaseDatabaseDumpRequest: S.Schema<DeleteHostingPrivateDatabaseDatabaseDumpRequest>;
+export interface DeleteHostingPrivateDatabaseDumpRequest {
+    /** Service name */
+    serviceName: string;
+    /** Dump ID */
+    dumpId: number;
+}
+export declare const DeleteHostingPrivateDatabaseDumpRequest: S.Schema<DeleteHostingPrivateDatabaseDumpRequest>;
+export interface DeleteHostingPrivateDatabaseLogSubscriptionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Subscription ID */
+    subscriptionId: string;
+}
+export declare const DeleteHostingPrivateDatabaseLogSubscriptionRequest: S.Schema<DeleteHostingPrivateDatabaseLogSubscriptionRequest>;
+export interface DeleteHostingPrivateDatabaseUserRequest {
+    /** Service name */
+    serviceName: string;
+    /** User name */
+    userName: string;
+}
+export declare const DeleteHostingPrivateDatabaseUserRequest: S.Schema<DeleteHostingPrivateDatabaseUserRequest>;
+export interface DeleteHostingPrivateDatabaseUserGrantRequest {
+    /** Service name */
+    serviceName: string;
+    /** User name */
+    userName: string;
+    /** Database name */
+    databaseName: string;
+}
+export declare const DeleteHostingPrivateDatabaseUserGrantRequest: S.Schema<DeleteHostingPrivateDatabaseUserGrantRequest>;
+export interface DeleteHostingPrivateDatabaseWebhostingNetworkRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const DeleteHostingPrivateDatabaseWebhostingNetworkRequest: S.Schema<DeleteHostingPrivateDatabaseWebhostingNetworkRequest>;
+export interface DeleteHostingPrivateDatabaseWhitelistRequest {
+    /** Service name */
+    serviceName: string;
+    /** Ip */
+    ip: string;
+}
+export declare const DeleteHostingPrivateDatabaseWhitelistRequest: S.Schema<DeleteHostingPrivateDatabaseWhitelistRequest>;
+export interface DisableHostingPrivateDatabaseDatabaseExtensionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Database name */
+    databaseName: string;
+    /** Extension name */
+    extensionName: string;
+}
+export declare const DisableHostingPrivateDatabaseDatabaseExtensionRequest: S.Schema<DisableHostingPrivateDatabaseDatabaseExtensionRequest>;
+export interface EnableHostingPrivateDatabaseDatabaseExtensionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Database name */
+    databaseName: string;
+    /** Extension name */
+    extensionName: string;
+}
+export declare const EnableHostingPrivateDatabaseDatabaseExtensionRequest: S.Schema<EnableHostingPrivateDatabaseDatabaseExtensionRequest>;
+export interface GenerateHostingPrivateDatabaseTemporaryLogsLinkRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GenerateHostingPrivateDatabaseTemporaryLogsLinkRequest: S.Schema<GenerateHostingPrivateDatabaseTemporaryLogsLinkRequest>;
+/** Temporary url information */
+export interface HostingPrivateDatabaseTemporaryUrlInformations {
+    /** Temporary url expiration date */
+    expirationDate?: string;
+    /** Temporary url */
+    url?: string;
+}
+export declare const HostingPrivateDatabaseTemporaryUrlInformations: S.Schema<HostingPrivateDatabaseTemporaryUrlInformations>;
+export interface GetHostingPrivateDatabaseRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetHostingPrivateDatabaseRequest: S.Schema<GetHostingPrivateDatabaseRequest>;
+/** Private database capability */
+export interface HostingPrivateDatabaseCapability {
+    /** Can the object be created */
+    create?: boolean;
+    /** Can the object be deleted */
+    delete?: boolean;
+    /** Object name */
+    object?: string;
+    /** Can the object be updated */
+    update?: boolean;
+}
+export declare const HostingPrivateDatabaseCapability: S.Schema<HostingPrivateDatabaseCapability>;
+/** Private database capabilities */
+export type HostingPrivateDatabaseServiceWithIAMCapabilitiesList = Array<HostingPrivateDatabaseCapability>;
+export declare const HostingPrivateDatabaseServiceWithIAMCapabilitiesList: S.Schema<HostingPrivateDatabaseServiceWithIAMCapabilitiesList>;
+/** Private database datacenter */
+export type HostingPrivateDatabaseDatacenterEnum = "bhs1" | "gra1" | "gra2" | "gra3";
+export declare const HostingPrivateDatabaseDatacenterEnum: any;
+/** Parameters required to query metrics from OpenTSDB */
+export interface HostingPrivateDatabaseGraphEndpoint {
+    /** The OpenTSDB host */
+    host?: string | null;
+    /** A read-only token */
+    readToken?: string | null;
+    /** A read-only token ID */
+    readTokenId?: string | null;
+}
+export declare const HostingPrivateDatabaseGraphEndpoint: S.Schema<HostingPrivateDatabaseGraphEndpoint>;
+/** Resource tags. Tags that were internally computed are prefixed with ovh: */
+export type IamResourceMetadataTagsMap = {
+    [key: string]: string | undefined;
+};
+export declare const IamResourceMetadataTagsMap: S.Schema<IamResourceMetadataTagsMap>;
+/** IAM resource metadata embedded in services models */
+export interface IamResourceMetadata {
+    /** Resource display name */
+    displayName?: string | null;
+    /** Unique identifier of the resource */
+    id?: string;
+    /** Resource tags. Tags that were internally computed are prefixed with ovh: */
+    tags?: IamResourceMetadataTagsMap | null;
+    /** Unique resource name used in policies */
+    urn?: string;
+}
+export declare const IamResourceMetadata: S.Schema<IamResourceMetadata>;
+/** Private database infrastructure */
+export type HostingPrivateDatabaseInfrastructureEnum = "docker";
+export declare const HostingPrivateDatabaseInfrastructureEnum: any;
+/** Available offers */
+export type HostingPrivateDatabaseOfferEnum = "classic" | "public";
+export declare const HostingPrivateDatabaseOfferEnum: any;
+/** A numeric value tagged with its unit */
+export interface ComplexTypeUnitAndValueLong {
+    /** Unit of the value */
+    unit?: string;
+    value?: number;
+}
+export declare const ComplexTypeUnitAndValueLong: S.Schema<ComplexTypeUnitAndValueLong>;
+/** Private database state */
+export type HostingPrivateDatabaseStateEnum = "detached" | "restartPending" | "startPending" | "started" | "stopPending" | "stopped";
+export declare const HostingPrivateDatabaseStateEnum: any;
+/** Private database type */
+export type HostingPrivateDatabaseTypeEnum = "mariadb" | "mysql" | "postgresql" | "redis";
+export declare const HostingPrivateDatabaseTypeEnum: any;
+/** Private database version */
+export type HostingPrivateDatabaseVersionEnum = "mariadb_10.11" | "mariadb_10.5" | "mariadb_10.6" | "mariadb_11.4" | "mysql_8.0" | "mysql_8.4" | "postgresql_13" | "postgresql_14" | "postgresql_15" | "postgresql_16" | "postgresql_17" | "redis_7.0" | "valkey_7.2";
+export declare const HostingPrivateDatabaseVersionEnum: any;
+/** Web Cloud Database */
+export interface HostingPrivateDatabaseServiceWithIAM {
+    /** Private database capabilities */
+    capabilities?: HostingPrivateDatabaseServiceWithIAMCapabilitiesList;
+    /** Number of cpu on your private database */
+    cpu?: number;
+    /** Datacenter where this private database is located */
+    datacenter?: HostingPrivateDatabaseDatacenterEnum;
+    /** Set the name displayed in customer panel for your private database (max 50 chars) */
+    displayName?: string | null;
+    /** Parameters required to query metrics from OpenTSDB */
+    graphEndpoint?: HostingPrivateDatabaseGraphEndpoint | null;
+    /** URL for the graphical user interface */
+    guiURL?: string | null;
+    /** Private database hostname */
+    hostname?: string;
+    /** Private database ftp hostname */
+    hostnameFtp?: string | null;
+    /** IAM resource metadata */
+    iam?: IamResourceMetadata | null;
+    /** Infrastructure where service was stored */
+    infrastructure?: HostingPrivateDatabaseInfrastructureEnum;
+    /** Private database ip */
+    ip?: string | null;
+    /** Date of the last data synchronization */
+    lastCheck?: string;
+    /** Type of the private database offer */
+    offer?: HostingPrivateDatabaseOfferEnum;
+    /** Private database service port */
+    port?: number;
+    /** Private database ftp port */
+    portFtp?: number | null;
+    /** Space allowed on your private database */
+    quotaSize?: ComplexTypeUnitAndValueLong;
+    /** Total space used on your private database */
+    quotaUsed?: ComplexTypeUnitAndValueLong;
+    /** Amount of ram on your private database */
+    ram?: ComplexTypeUnitAndValueLong;
+    /** Private database server name */
+    server?: string;
+    /** Service name */
+    serviceName?: string;
+    /** Private database state */
+    state?: HostingPrivateDatabaseStateEnum;
+    /** Return the TLS certificate authority used by the private database */
+    tlsCa?: string | null;
+    /** Private database type */
+    type?: HostingPrivateDatabaseTypeEnum;
+    /** Private database version */
+    version?: HostingPrivateDatabaseVersionEnum;
+    /** Private database version label */
+    versionLabel?: string;
+    /** Private database version number */
+    versionNumber?: number;
+}
+export declare const HostingPrivateDatabaseServiceWithIAM: S.Schema<HostingPrivateDatabaseServiceWithIAM>;
+export interface GetHostingPrivateDatabaseDatabaseRequest {
+    /** Service name */
+    serviceName: string;
+    /** Database name */
+    databaseName: string;
+}
+export declare const GetHostingPrivateDatabaseDatabaseRequest: S.Schema<GetHostingPrivateDatabaseDatabaseRequest>;
+/** Users */
+export interface HostingPrivateDatabaseDatabaseUser {
+    /** The grantId associated for this databaseName and this userName */
+    grantId?: number;
+    /** User's rights on this database */
+    grantType?: HostingPrivateDatabaseGrantGrantEnum;
+    /** User's name granted on this database */
+    userName?: string;
+}
+export declare const HostingPrivateDatabaseDatabaseUser: S.Schema<HostingPrivateDatabaseDatabaseUser>;
+/** Users granted to this database */
+export type HostingPrivateDatabaseDatabaseUsersList = Array<HostingPrivateDatabaseDatabaseUser>;
+export declare const HostingPrivateDatabaseDatabaseUsersList: S.Schema<HostingPrivateDatabaseDatabaseUsersList>;
+/** Databases */
+export interface HostingPrivateDatabaseDatabase {
+    /** Time of the next backup (every day) */
+    backupTime?: string | null;
+    /** Creation date of the database */
+    creationDate?: string;
+    /** Database name */
+    databaseName?: string;
+    /** Space used by the database */
+    quotaUsed?: ComplexTypeUnitAndValueLong;
+    /** Users granted to this database */
+    users?: HostingPrivateDatabaseDatabaseUsersList;
+}
+export declare const HostingPrivateDatabaseDatabase: S.Schema<HostingPrivateDatabaseDatabase>;
+export interface GetHostingPrivateDatabaseDatabaseCopyRequest {
+    /** Service name */
+    serviceName: string;
+    /** Database name */
+    databaseName: string;
+    /** Id */
+    id: string;
+}
+export declare const GetHostingPrivateDatabaseDatabaseCopyRequest: S.Schema<GetHostingPrivateDatabaseDatabaseCopyRequest>;
+export interface GetHostingPrivateDatabaseDatabaseDumpRequest {
+    /** Service name */
+    serviceName: string;
+    /** Database name */
+    databaseName: string;
+    /** Id */
+    id: number;
+}
+export declare const GetHostingPrivateDatabaseDatabaseDumpRequest: S.Schema<GetHostingPrivateDatabaseDatabaseDumpRequest>;
+/** Dumps */
+export interface HostingPrivateDatabaseDatabaseDump {
+    /** Creation date of the dump */
+    creationDate?: string;
+    /** Dump of this database name */
+    databaseName?: string;
+    /** Automatic deletion date of the dump */
+    deletionDate?: string;
+    /** Dump id */
+    id?: number;
+    /** Dump URL access */
+    url?: string;
+}
+export declare const HostingPrivateDatabaseDatabaseDump: S.Schema<HostingPrivateDatabaseDatabaseDump>;
+export interface GetHostingPrivateDatabaseDatabaseExtensionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Database name */
+    databaseName: string;
+    /** Extension name */
+    extensionName: string;
+}
+export declare const GetHostingPrivateDatabaseDatabaseExtensionRequest: S.Schema<GetHostingPrivateDatabaseDatabaseExtensionRequest>;
+/** Required extensions */
+export type HostingPrivateDatabaseExtensionRequiredExtensionsList = Array<string>;
+export declare const HostingPrivateDatabaseExtensionRequiredExtensionsList: S.Schema<HostingPrivateDatabaseExtensionRequiredExtensionsList>;
+/** Extension status */
+export type HostingPrivateDatabaseExtensionStatusEnum = "disabled" | "disabling" | "enabled" | "enabling";
+export declare const HostingPrivateDatabaseExtensionStatusEnum: any;
+/** Webcloud Database extension */
+export interface HostingPrivateDatabaseExtension {
+    /** Extension details */
+    description?: string;
+    /** Extension name */
+    extensionName?: string;
+    /** Required extensions */
+    requiredExtensions?: HostingPrivateDatabaseExtensionRequiredExtensionsList;
+    /** Extension status */
+    status?: HostingPrivateDatabaseExtensionStatusEnum;
+}
+export declare const HostingPrivateDatabaseExtension: S.Schema<HostingPrivateDatabaseExtension>;
+export interface GetHostingPrivateDatabaseDumpRequest {
+    /** Service name */
+    serviceName: string;
+    /** Dump ID */
+    dumpId: number;
+}
+export declare const GetHostingPrivateDatabaseDumpRequest: S.Schema<GetHostingPrivateDatabaseDumpRequest>;
+/** Dumps */
+export interface HostingPrivateDatabaseDump {
+    /** Creation date of the dump */
+    creationDate?: string;
+    /** Dump of this database name */
+    databaseName?: string;
+    /** Automatic deletion date of the dump */
+    deletionDate?: string;
+    /** Dump id */
+    dumpId?: number;
+    /** Dump orphan flag (true if database does not exists) */
+    orphan?: boolean;
+    /** Dump URL access */
+    url?: string;
+}
+export declare const HostingPrivateDatabaseDump: S.Schema<HostingPrivateDatabaseDump>;
+export interface GetHostingPrivateDatabaseLogKindRequest {
+    /** Service name */
+    serviceName: string;
+    /** Name */
+    name: string;
+}
+export declare const GetHostingPrivateDatabaseLogKindRequest: S.Schema<GetHostingPrivateDatabaseLogKindRequest>;
+/** List of additional log fields managed in this log kind */
+export type DbaasLogsLogKindAdditionalReturnedFieldsList = Array<string>;
+export declare const DbaasLogsLogKindAdditionalReturnedFieldsList: S.Schema<DbaasLogsLogKindAdditionalReturnedFieldsList>;
+/** Log kind */
+export interface DbaasLogsLogKind {
+    /** List of additional log fields managed in this log kind */
+    additionalReturnedFields?: DbaasLogsLogKindAdditionalReturnedFieldsList;
+    /** Creation date of the log kind */
+    createdAt?: string;
+    /** Log kind display name */
+    displayName?: string;
+    /** Log kind ID */
+    kindId?: string;
+    /** Log kind name */
+    name?: string;
+    /** Last update date of the log kind */
+    updatedAt?: string;
+}
+export declare const DbaasLogsLogKind: S.Schema<DbaasLogsLogKind>;
+export interface GetHostingPrivateDatabaseLogSubscriptionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Subscription ID */
+    subscriptionId: string;
+}
+export declare const GetHostingPrivateDatabaseLogSubscriptionRequest: S.Schema<GetHostingPrivateDatabaseLogSubscriptionRequest>;
+/** Log subscription resource */
+export interface DbaasLogsLogSubscriptionResource {
+    /** Name of subscribed resource */
+    name?: string;
+    /** Type of subscribed resource */
+    type?: string;
+}
+export declare const DbaasLogsLogSubscriptionResource: S.Schema<DbaasLogsLogSubscriptionResource>;
+/** Log subscription */
+export interface DbaasLogsLogSubscription {
+    /** Creation date of the subscription */
+    createdAt?: string;
+    /** Log kind name of this subscription */
+    kind?: string;
+    /** Subscribed resource, where the logs come from */
+    resource?: DbaasLogsLogSubscriptionResource;
+    /** Name of the destination log service */
+    serviceName?: string;
+    /** Id of the destination log stream */
+    streamId?: string;
+    /** Subscription ID */
+    subscriptionId?: string;
+    /** Last update date of the subscription */
+    updatedAt?: string;
+}
+export declare const DbaasLogsLogSubscription: S.Schema<DbaasLogsLogSubscription>;
+export interface GetHostingPrivateDatabaseMetricsTokenRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetHostingPrivateDatabaseMetricsTokenRequest: S.Schema<GetHostingPrivateDatabaseMetricsTokenRequest>;
+/** Metrics token */
+export interface HostingPrivateDatabaseMetricsToken {
+    /** Backend url */
+    endpoint?: string;
+    /** Generated token */
+    token?: string;
+}
+export declare const HostingPrivateDatabaseMetricsToken: S.Schema<HostingPrivateDatabaseMetricsToken>;
+export interface GetHostingPrivateDatabaseServiceInfosRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetHostingPrivateDatabaseServiceInfosRequest: S.Schema<GetHostingPrivateDatabaseServiceInfosRequest>;
+/** All the possible renew period of your service in month */
+export type ServicesServicePossibleRenewPeriodList = Array<number>;
+export declare const ServicesServicePossibleRenewPeriodList: S.Schema<ServicesServicePossibleRenewPeriodList>;
+/** Map a possible renew for a specific service */
+export interface ServiceRenewType {
+    /** The service is automatically renewed */
+    automatic?: boolean;
+    /** The service will be deleted at expiration */
+    deleteAtExpiration?: boolean;
+    /** The service forced to be renewed */
+    forced?: boolean;
+    /** The service needs to be manually renewed and paid */
+    manualPayment?: boolean | null;
+    /** period of renew in month */
+    period?: number | null;
+}
+export declare const ServiceRenewType: S.Schema<ServiceRenewType>;
+/** Detailed renewal type of a service */
+export type ServiceRenewalTypeEnum = "automaticForcedProduct" | "automaticV2012" | "automaticV2014" | "automaticV2016" | "manual" | "oneShot" | "option";
+export declare const ServiceRenewalTypeEnum: any;
+/** service.StateEnum */
+export type ServiceStateEnum = "autorenewInProgress" | "expired" | "inCreation" | "ok" | "pendingDebt" | "unPaid";
+export declare const ServiceStateEnum: any;
+/** Details about a Service */
+export interface ServicesService {
+    /** Indicates that the service can be set up to be deleted at expiration */
+    canDeleteAtExpiration?: boolean;
+    contactAdmin?: string;
+    contactBilling?: string;
+    contactTech?: string;
+    creation?: string;
+    domain?: string;
+    engagedUpTo?: string | null;
+    expiration?: string;
+    /** All the possible renew period of your service in month */
+    possibleRenewPeriod?: ServicesServicePossibleRenewPeriodList | null;
+    /** Way of handling the renew */
+    renew?: ServiceRenewType | null;
+    renewalType?: ServiceRenewalTypeEnum;
+    serviceId?: number;
+    status?: ServiceStateEnum;
+}
+export declare const ServicesService: S.Schema<ServicesService>;
+export interface GetHostingPrivateDatabaseTaskRequest {
+    /** Service name */
+    serviceName: string;
+    /** Id */
+    id: number;
+}
+export declare const GetHostingPrivateDatabaseTaskRequest: S.Schema<GetHostingPrivateDatabaseTaskRequest>;
+export interface GetHostingPrivateDatabaseUserRequest {
+    /** Service name */
+    serviceName: string;
+    /** User name */
+    userName: string;
+}
+export declare const GetHostingPrivateDatabaseUserRequest: S.Schema<GetHostingPrivateDatabaseUserRequest>;
+/** Users */
+export interface HostingPrivateDatabaseUserDatabase {
+    /** Database granted for this user */
+    databaseName?: string;
+    /** The grantId associated for this databaseName and this userName */
+    grantId?: number;
+    /** User's rights on this database */
+    grantType?: HostingPrivateDatabaseGrantGrantEnum;
+}
+export declare const HostingPrivateDatabaseUserDatabase: S.Schema<HostingPrivateDatabaseUserDatabase>;
+/** Databases granted for this user */
+export type HostingPrivateDatabaseUserDatabasesList = Array<HostingPrivateDatabaseUserDatabase>;
+export declare const HostingPrivateDatabaseUserDatabasesList: S.Schema<HostingPrivateDatabaseUserDatabasesList>;
+/** Users */
+export interface HostingPrivateDatabaseUser {
+    /** Creation date of the user */
+    creationDate?: string;
+    /** Databases granted for this user */
+    databases?: HostingPrivateDatabaseUserDatabasesList;
+    /** User name used to connect to your databases */
+    userName?: string;
+}
+export declare const HostingPrivateDatabaseUser: S.Schema<HostingPrivateDatabaseUser>;
+export interface GetHostingPrivateDatabaseUserGrantRequest {
+    /** Service name */
+    serviceName: string;
+    /** User name */
+    userName: string;
+    /** Database name */
+    databaseName: string;
+}
+export declare const GetHostingPrivateDatabaseUserGrantRequest: S.Schema<GetHostingPrivateDatabaseUserGrantRequest>;
+/** Grant */
+export interface HostingPrivateDatabaseUserGrant {
+    /** Automatic deletion date of the dump */
+    creationDate?: string;
+    /** Dump of this database name */
+    databaseName?: string;
+    /** Grant set */
+    grant?: HostingPrivateDatabaseGrantGrantEnum;
+}
+export declare const HostingPrivateDatabaseUserGrant: S.Schema<HostingPrivateDatabaseUserGrant>;
+export interface GetHostingPrivateDatabaseWebhostingNetworkRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetHostingPrivateDatabaseWebhostingNetworkRequest: S.Schema<GetHostingPrivateDatabaseWebhostingNetworkRequest>;
+/** Webhosting network status */
+export type HostingPrivateDatabaseWebhostingNetworkStatusEnum = "disabled" | "disabling" | "enabled" | "enabling";
+export declare const HostingPrivateDatabaseWebhostingNetworkStatusEnum: any;
+/** webhosting Network */
+export interface HostingPrivateDatabaseWebhostingNetwork {
+    /** Webhosting network status */
+    status?: HostingPrivateDatabaseWebhostingNetworkStatusEnum;
+}
+export declare const HostingPrivateDatabaseWebhostingNetwork: S.Schema<HostingPrivateDatabaseWebhostingNetwork>;
+export interface GetHostingPrivateDatabaseWhitelistRequest {
+    /** Service name */
+    serviceName: string;
+    /** Ip */
+    ip: string;
+}
+export declare const GetHostingPrivateDatabaseWhitelistRequest: S.Schema<GetHostingPrivateDatabaseWhitelistRequest>;
+/** Whitelist status */
+export type HostingPrivateDatabaseWhitelistStatusEnum = "created" | "creating" | "deleting" | "updating";
+export declare const HostingPrivateDatabaseWhitelistStatusEnum: any;
+/** Whitelist */
+export interface HostingPrivateDatabaseWhitelist {
+    /** Creation date of this whitelist */
+    creationDate?: string;
+    /** The whitelisted IP in your Web Cloud Database */
+    ip?: string;
+    /** The last update date of this whitelist */
+    lastUpdate?: string;
+    /** Custom name for your Whitelisted IP */
+    name?: string | null;
+    /** Authorize this IP to access service port */
+    service?: boolean;
+    /** Authorize this IP to access sftp port */
+    sftp?: boolean;
+    /** Whitelist status */
+    status?: HostingPrivateDatabaseWhitelistStatusEnum;
+    /** The id of the task working on this object */
+    taskId?: number | null;
+}
+export declare const HostingPrivateDatabaseWhitelist: S.Schema<HostingPrivateDatabaseWhitelist>;
+export interface ImportHostingPrivateDatabaseDatabaseRequest {
+    /** Service name */
+    serviceName: string;
+    /** Database name */
+    databaseName: string;
+    /** Documents ID of the dump from /me/documents */
+    documentId: string;
+    /** Whether to flush the database before importing the dump (default to false) */
+    flushDatabase?: boolean;
+    /** Whether to receive an email when the import is complete (default to false) */
+    sendEmail?: boolean;
+}
+export declare const ImportHostingPrivateDatabaseDatabaseRequest: S.Schema<ImportHostingPrivateDatabaseDatabaseRequest>;
+/** Resource tag filter */
+export interface IamResourceTagFilterInput {
+}
+export declare const IamResourceTagFilterInput: S.Schema<IamResourceTagFilterInput>;
+export type ListHostingPrivateDatabaseRequestIamTagsValueList = Array<IamResourceTagFilterInput>;
+export declare const ListHostingPrivateDatabaseRequestIamTagsValueList: S.Schema<ListHostingPrivateDatabaseRequestIamTagsValueList>;
+export type ListHostingPrivateDatabaseRequestIamTagsMap = {
+    [key: string]: ListHostingPrivateDatabaseRequestIamTagsValueList | undefined;
+};
+export declare const ListHostingPrivateDatabaseRequestIamTagsMap: S.Schema<ListHostingPrivateDatabaseRequestIamTagsMap>;
+export interface ListHostingPrivateDatabaseRequest {
+    /** Filter resources on IAM tags */
+    iamTags?: ListHostingPrivateDatabaseRequestIamTagsMap;
+}
+export declare const ListHostingPrivateDatabaseRequest: S.Schema<ListHostingPrivateDatabaseRequest>;
+export type ListHostingPrivateDatabaseResponseBodyList = Array<string>;
+export declare const ListHostingPrivateDatabaseResponseBodyList: S.Schema<ListHostingPrivateDatabaseResponseBodyList>;
+export type ListHostingPrivateDatabaseResponse = ListHostingPrivateDatabaseResponseBodyList;
+export declare const ListHostingPrivateDatabaseResponse: S.Schema<ListHostingPrivateDatabaseResponse>;
+export interface ListHostingPrivateDatabaseAvailableOrderCapacitiesRequest {
+    offer: HostingPrivateDatabaseOfferEnum | (string & {});
+}
+export declare const ListHostingPrivateDatabaseAvailableOrderCapacitiesRequest: S.Schema<ListHostingPrivateDatabaseAvailableOrderCapacitiesRequest>;
+/** A list of datacenter available for this offer */
+export type HostingPrivateDatabaseAvailableOrderCapacitiesDatacenterList = Array<HostingPrivateDatabaseDatacenterEnum>;
+export declare const HostingPrivateDatabaseAvailableOrderCapacitiesDatacenterList: S.Schema<HostingPrivateDatabaseAvailableOrderCapacitiesDatacenterList>;
+/** Private database available ram sizes */
+export type HostingPrivateDatabaseAvailableRamSizeEnum = "1024" | "2048" | "4096" | "512";
+export declare const HostingPrivateDatabaseAvailableRamSizeEnum: any;
+/** A list of ram size available for this offer */
+export type HostingPrivateDatabaseAvailableOrderCapacitiesRamList = Array<HostingPrivateDatabaseAvailableRamSizeEnum>;
+export declare const HostingPrivateDatabaseAvailableOrderCapacitiesRamList: S.Schema<HostingPrivateDatabaseAvailableOrderCapacitiesRamList>;
+/** A list of version available for this offer */
+export type HostingPrivateDatabaseAvailableOrderCapacitiesVersionList = Array<HostingPrivateDatabaseAvailableVersionEnum>;
+export declare const HostingPrivateDatabaseAvailableOrderCapacitiesVersionList: S.Schema<HostingPrivateDatabaseAvailableOrderCapacitiesVersionList>;
+/** Description for available order capacities following an offer */
+export interface HostingPrivateDatabaseAvailableOrderCapacities {
+    /** A list of datacenter available for this offer */
+    datacenter?: HostingPrivateDatabaseAvailableOrderCapacitiesDatacenterList;
+    /** Offer */
+    offer?: HostingPrivateDatabaseOfferEnum;
+    /** A list of ram size available for this offer */
+    ram?: HostingPrivateDatabaseAvailableOrderCapacitiesRamList;
+    /** A list of version available for this offer */
+    version?: HostingPrivateDatabaseAvailableOrderCapacitiesVersionList;
+}
+export declare const HostingPrivateDatabaseAvailableOrderCapacities: S.Schema<HostingPrivateDatabaseAvailableOrderCapacities>;
+export interface ListHostingPrivateDatabaseAvailableVersionsRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListHostingPrivateDatabaseAvailableVersionsRequest: S.Schema<ListHostingPrivateDatabaseAvailableVersionsRequest>;
+export type ListHostingPrivateDatabaseAvailableVersionsResponseBodyList = Array<HostingPrivateDatabaseAvailableVersionEnum>;
+export declare const ListHostingPrivateDatabaseAvailableVersionsResponseBodyList: S.Schema<ListHostingPrivateDatabaseAvailableVersionsResponseBodyList>;
+export type ListHostingPrivateDatabaseAvailableVersionsResponse = ListHostingPrivateDatabaseAvailableVersionsResponseBodyList;
+export declare const ListHostingPrivateDatabaseAvailableVersionsResponse: S.Schema<ListHostingPrivateDatabaseAvailableVersionsResponse>;
+export interface ListHostingPrivateDatabaseConfigRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListHostingPrivateDatabaseConfigRequest: S.Schema<ListHostingPrivateDatabaseConfigRequest>;
+/** Configuration available values */
+export type HostingPrivateDatabaseConfigDetailAvailableValuesList = Array<string>;
+export declare const HostingPrivateDatabaseConfigDetailAvailableValuesList: S.Schema<HostingPrivateDatabaseConfigDetailAvailableValuesList>;
+/** Web Cloud Database config type */
+export type HostingPrivateDatabaseConfigTypeEnum = "boolean" | "number" | "string";
+export declare const HostingPrivateDatabaseConfigTypeEnum: any;
+/** Config detail */
+export interface HostingPrivateDatabaseConfigDetail {
+    /** Configuration available values */
+    availableValues?: HostingPrivateDatabaseConfigDetailAvailableValuesList;
+    /** Configuration default value */
+    defaultValue?: string;
+    /** Configuration description */
+    description?: string;
+    /** Configuration key name */
+    key?: string;
+    /** Configuration last update */
+    lastUpdate?: string;
+    /** Configuration value type */
+    type?: HostingPrivateDatabaseConfigTypeEnum;
+    /** Configuration unit type */
+    unit?: string | null;
+    /** Configuration current value */
+    value?: string;
+}
+export declare const HostingPrivateDatabaseConfigDetail: S.Schema<HostingPrivateDatabaseConfigDetail>;
+/** Configuration details */
+export type HostingPrivateDatabaseConfigsDetailsList = Array<HostingPrivateDatabaseConfigDetail>;
+export declare const HostingPrivateDatabaseConfigsDetailsList: S.Schema<HostingPrivateDatabaseConfigsDetailsList>;
+/** Web Cloud Database config status */
+export type HostingPrivateDatabaseConfigStatusEnum = "applied" | "updating";
+export declare const HostingPrivateDatabaseConfigStatusEnum: any;
+/** Configs */
+export interface HostingPrivateDatabaseConfigs {
+    /** Configuration details */
+    details?: HostingPrivateDatabaseConfigsDetailsList;
+    /** Configuration last update */
+    lastUpdate?: string;
+    /** Configuration status */
+    status?: HostingPrivateDatabaseConfigStatusEnum;
+    /** Configuration linked task id */
+    taskId?: number | null;
+}
+export declare const HostingPrivateDatabaseConfigs: S.Schema<HostingPrivateDatabaseConfigs>;
+export interface ListHostingPrivateDatabaseCpuThrottleRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListHostingPrivateDatabaseCpuThrottleRequest: S.Schema<ListHostingPrivateDatabaseCpuThrottleRequest>;
+/** CPU throttle informations */
+export interface HostingPrivateDatabaseCpuThrottle {
+    /** End date of the CPU throttle */
+    endDate?: string | null;
+    /** Start date of the CPU throttle */
+    startDate?: string;
+}
+export declare const HostingPrivateDatabaseCpuThrottle: S.Schema<HostingPrivateDatabaseCpuThrottle>;
+export type ListHostingPrivateDatabaseCpuThrottleResponseBodyList = Array<HostingPrivateDatabaseCpuThrottle>;
+export declare const ListHostingPrivateDatabaseCpuThrottleResponseBodyList: S.Schema<ListHostingPrivateDatabaseCpuThrottleResponseBodyList>;
+export type ListHostingPrivateDatabaseCpuThrottleResponse = ListHostingPrivateDatabaseCpuThrottleResponseBodyList;
+export declare const ListHostingPrivateDatabaseCpuThrottleResponse: S.Schema<ListHostingPrivateDatabaseCpuThrottleResponse>;
+export interface ListHostingPrivateDatabaseDatabaseRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListHostingPrivateDatabaseDatabaseRequest: S.Schema<ListHostingPrivateDatabaseDatabaseRequest>;
+export type ListHostingPrivateDatabaseDatabaseResponseBodyList = Array<string>;
+export declare const ListHostingPrivateDatabaseDatabaseResponseBodyList: S.Schema<ListHostingPrivateDatabaseDatabaseResponseBodyList>;
+export type ListHostingPrivateDatabaseDatabaseResponse = ListHostingPrivateDatabaseDatabaseResponseBodyList;
+export declare const ListHostingPrivateDatabaseDatabaseResponse: S.Schema<ListHostingPrivateDatabaseDatabaseResponse>;
+export interface ListHostingPrivateDatabaseDatabaseCopyRequest {
+    /** Service name */
+    serviceName: string;
+    /** Database name */
+    databaseName: string;
+}
+export declare const ListHostingPrivateDatabaseDatabaseCopyRequest: S.Schema<ListHostingPrivateDatabaseDatabaseCopyRequest>;
+export type ListHostingPrivateDatabaseDatabaseCopyResponseBodyList = Array<string>;
+export declare const ListHostingPrivateDatabaseDatabaseCopyResponseBodyList: S.Schema<ListHostingPrivateDatabaseDatabaseCopyResponseBodyList>;
+export type ListHostingPrivateDatabaseDatabaseCopyResponse = ListHostingPrivateDatabaseDatabaseCopyResponseBodyList;
+export declare const ListHostingPrivateDatabaseDatabaseCopyResponse: S.Schema<ListHostingPrivateDatabaseDatabaseCopyResponse>;
+export interface ListHostingPrivateDatabaseDatabaseDumpRequest {
+    /** Service name */
+    serviceName: string;
+    /** Database name */
+    databaseName: string;
+}
+export declare const ListHostingPrivateDatabaseDatabaseDumpRequest: S.Schema<ListHostingPrivateDatabaseDatabaseDumpRequest>;
+export type ListHostingPrivateDatabaseDatabaseDumpResponseBodyList = Array<number>;
+export declare const ListHostingPrivateDatabaseDatabaseDumpResponseBodyList: S.Schema<ListHostingPrivateDatabaseDatabaseDumpResponseBodyList>;
+export type ListHostingPrivateDatabaseDatabaseDumpResponse = ListHostingPrivateDatabaseDatabaseDumpResponseBodyList;
+export declare const ListHostingPrivateDatabaseDatabaseDumpResponse: S.Schema<ListHostingPrivateDatabaseDatabaseDumpResponse>;
+export interface ListHostingPrivateDatabaseDatabaseExtensionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Database name */
+    databaseName: string;
+    /** Filter results on extension name (like) */
+    extensionName?: string;
+    /** Filter results on status (=) */
+    status?: HostingPrivateDatabaseExtensionStatusEnum | (string & {});
+}
+export declare const ListHostingPrivateDatabaseDatabaseExtensionRequest: S.Schema<ListHostingPrivateDatabaseDatabaseExtensionRequest>;
+export type ListHostingPrivateDatabaseDatabaseExtensionResponseBodyList = Array<string>;
+export declare const ListHostingPrivateDatabaseDatabaseExtensionResponseBodyList: S.Schema<ListHostingPrivateDatabaseDatabaseExtensionResponseBodyList>;
+export type ListHostingPrivateDatabaseDatabaseExtensionResponse = ListHostingPrivateDatabaseDatabaseExtensionResponseBodyList;
+export declare const ListHostingPrivateDatabaseDatabaseExtensionResponse: S.Schema<ListHostingPrivateDatabaseDatabaseExtensionResponse>;
+export interface ListHostingPrivateDatabaseDumpRequest {
+    /** Service name */
+    serviceName: string;
+    /** Filter the value of databaseName property (like) */
+    databaseName?: string;
+    /** Filter the value of orphan property (=) */
+    orphan?: boolean;
+}
+export declare const ListHostingPrivateDatabaseDumpRequest: S.Schema<ListHostingPrivateDatabaseDumpRequest>;
+export type ListHostingPrivateDatabaseDumpResponseBodyList = Array<number>;
+export declare const ListHostingPrivateDatabaseDumpResponseBodyList: S.Schema<ListHostingPrivateDatabaseDumpResponseBodyList>;
+export type ListHostingPrivateDatabaseDumpResponse = ListHostingPrivateDatabaseDumpResponseBodyList;
+export declare const ListHostingPrivateDatabaseDumpResponse: S.Schema<ListHostingPrivateDatabaseDumpResponse>;
+export interface ListHostingPrivateDatabaseLogKindRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListHostingPrivateDatabaseLogKindRequest: S.Schema<ListHostingPrivateDatabaseLogKindRequest>;
+export type ListHostingPrivateDatabaseLogKindResponseBodyList = Array<string>;
+export declare const ListHostingPrivateDatabaseLogKindResponseBodyList: S.Schema<ListHostingPrivateDatabaseLogKindResponseBodyList>;
+export type ListHostingPrivateDatabaseLogKindResponse = ListHostingPrivateDatabaseLogKindResponseBodyList;
+export declare const ListHostingPrivateDatabaseLogKindResponse: S.Schema<ListHostingPrivateDatabaseLogKindResponse>;
+export interface ListHostingPrivateDatabaseLogSubscriptionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Filter on a specific kind */
+    kind?: string;
+}
+export declare const ListHostingPrivateDatabaseLogSubscriptionRequest: S.Schema<ListHostingPrivateDatabaseLogSubscriptionRequest>;
+export type ListHostingPrivateDatabaseLogSubscriptionResponseBodyList = Array<string>;
+export declare const ListHostingPrivateDatabaseLogSubscriptionResponseBodyList: S.Schema<ListHostingPrivateDatabaseLogSubscriptionResponseBodyList>;
+export type ListHostingPrivateDatabaseLogSubscriptionResponse = ListHostingPrivateDatabaseLogSubscriptionResponseBodyList;
+export declare const ListHostingPrivateDatabaseLogSubscriptionResponse: S.Schema<ListHostingPrivateDatabaseLogSubscriptionResponse>;
+export interface ListHostingPrivateDatabaseOomRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListHostingPrivateDatabaseOomRequest: S.Schema<ListHostingPrivateDatabaseOomRequest>;
+/** List of privatesql OOM kill */
+export interface HostingPrivateDatabaseOom {
+    /** Date of the OOM kill */
+    date?: string;
+    /** Memory size reached */
+    sizeReached?: number;
+}
+export declare const HostingPrivateDatabaseOom: S.Schema<HostingPrivateDatabaseOom>;
+export type ListHostingPrivateDatabaseOomResponseBodyList = Array<HostingPrivateDatabaseOom>;
+export declare const ListHostingPrivateDatabaseOomResponseBodyList: S.Schema<ListHostingPrivateDatabaseOomResponseBodyList>;
+export type ListHostingPrivateDatabaseOomResponse = ListHostingPrivateDatabaseOomResponseBodyList;
+export declare const ListHostingPrivateDatabaseOomResponse: S.Schema<ListHostingPrivateDatabaseOomResponse>;
+export interface ListHostingPrivateDatabaseTasksRequest {
+    /** Service name */
+    serviceName: string;
+    /** Filter the value of function property */
+    function?: HostingPrivateDatabaseTaskFunctionEnum | (string & {});
+    /** Filter the value of status property */
+    status?: HostingPrivateDatabaseTaskStatusEnum | (string & {});
+}
+export declare const ListHostingPrivateDatabaseTasksRequest: S.Schema<ListHostingPrivateDatabaseTasksRequest>;
+export type ListHostingPrivateDatabaseTasksResponseBodyList = Array<number>;
+export declare const ListHostingPrivateDatabaseTasksResponseBodyList: S.Schema<ListHostingPrivateDatabaseTasksResponseBodyList>;
+export type ListHostingPrivateDatabaseTasksResponse = ListHostingPrivateDatabaseTasksResponseBodyList;
+export declare const ListHostingPrivateDatabaseTasksResponse: S.Schema<ListHostingPrivateDatabaseTasksResponse>;
+export interface ListHostingPrivateDatabaseUserRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListHostingPrivateDatabaseUserRequest: S.Schema<ListHostingPrivateDatabaseUserRequest>;
+export type ListHostingPrivateDatabaseUserResponseBodyList = Array<string>;
+export declare const ListHostingPrivateDatabaseUserResponseBodyList: S.Schema<ListHostingPrivateDatabaseUserResponseBodyList>;
+export type ListHostingPrivateDatabaseUserResponse = ListHostingPrivateDatabaseUserResponseBodyList;
+export declare const ListHostingPrivateDatabaseUserResponse: S.Schema<ListHostingPrivateDatabaseUserResponse>;
+export interface ListHostingPrivateDatabaseUserGrantRequest {
+    /** Service name */
+    serviceName: string;
+    /** User name */
+    userName: string;
+}
+export declare const ListHostingPrivateDatabaseUserGrantRequest: S.Schema<ListHostingPrivateDatabaseUserGrantRequest>;
+export type ListHostingPrivateDatabaseUserGrantResponseBodyList = Array<string>;
+export declare const ListHostingPrivateDatabaseUserGrantResponseBodyList: S.Schema<ListHostingPrivateDatabaseUserGrantResponseBodyList>;
+export type ListHostingPrivateDatabaseUserGrantResponse = ListHostingPrivateDatabaseUserGrantResponseBodyList;
+export declare const ListHostingPrivateDatabaseUserGrantResponse: S.Schema<ListHostingPrivateDatabaseUserGrantResponse>;
+export interface ListHostingPrivateDatabaseWebsRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListHostingPrivateDatabaseWebsRequest: S.Schema<ListHostingPrivateDatabaseWebsRequest>;
+export type ListHostingPrivateDatabaseWebsResponseBodyList = Array<string>;
+export declare const ListHostingPrivateDatabaseWebsResponseBodyList: S.Schema<ListHostingPrivateDatabaseWebsResponseBodyList>;
+export type ListHostingPrivateDatabaseWebsResponse = ListHostingPrivateDatabaseWebsResponseBodyList;
+export declare const ListHostingPrivateDatabaseWebsResponse: S.Schema<ListHostingPrivateDatabaseWebsResponse>;
+export interface ListHostingPrivateDatabaseWhitelistRequest {
+    /** Service name */
+    serviceName: string;
+    /** Filter the value of ip property (contains or equals) */
+    ip?: string;
+    /** Filter the value of service property */
+    service?: boolean;
+    /** Filter the value of sftp property */
+    sftp?: boolean;
+}
+export declare const ListHostingPrivateDatabaseWhitelistRequest: S.Schema<ListHostingPrivateDatabaseWhitelistRequest>;
+export type ListHostingPrivateDatabaseWhitelistResponseBodyList = Array<string>;
+export declare const ListHostingPrivateDatabaseWhitelistResponseBodyList: S.Schema<ListHostingPrivateDatabaseWhitelistResponseBodyList>;
+export type ListHostingPrivateDatabaseWhitelistResponse = ListHostingPrivateDatabaseWhitelistResponseBodyList;
+export declare const ListHostingPrivateDatabaseWhitelistResponse: S.Schema<ListHostingPrivateDatabaseWhitelistResponse>;
+export interface PutHostingPrivateDatabaseRequest {
+    /** Service name */
+    serviceName: string;
+    /** Set the name displayed in customer panel for your private database (max 50 chars) */
+    displayName?: string | null;
+}
+export declare const PutHostingPrivateDatabaseRequest: S.Schema<PutHostingPrivateDatabaseRequest>;
+export interface PutHostingPrivateDatabaseResponse {
+}
+export declare const PutHostingPrivateDatabaseResponse: S.Schema<PutHostingPrivateDatabaseResponse>;
+export interface PutHostingPrivateDatabaseServiceInfosRequest {
+    /** Service name */
+    serviceName: string;
+    /** Way of handling the renew */
+    renew?: ServiceRenewType | null;
+}
+export declare const PutHostingPrivateDatabaseServiceInfosRequest: S.Schema<PutHostingPrivateDatabaseServiceInfosRequest>;
+export interface PutHostingPrivateDatabaseServiceInfosResponse {
+}
+export declare const PutHostingPrivateDatabaseServiceInfosResponse: S.Schema<PutHostingPrivateDatabaseServiceInfosResponse>;
+export interface PutHostingPrivateDatabaseWhitelistRequest {
+    /** Service name */
+    serviceName: string;
+    /** Ip */
+    ip: string;
+    /** Custom name for your Whitelisted IP */
+    name?: string | null;
+    /** Authorize this IP to access service port */
+    service?: boolean;
+    /** Authorize this IP to access sftp port */
+    sftp?: boolean;
+}
+export declare const PutHostingPrivateDatabaseWhitelistRequest: S.Schema<PutHostingPrivateDatabaseWhitelistRequest>;
+export interface PutHostingPrivateDatabaseWhitelistResponse {
+}
+export declare const PutHostingPrivateDatabaseWhitelistResponse: S.Schema<PutHostingPrivateDatabaseWhitelistResponse>;
+export interface RestartHostingPrivateDatabaseRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const RestartHostingPrivateDatabaseRequest: S.Schema<RestartHostingPrivateDatabaseRequest>;
+export interface RestoreHostingPrivateDatabaseDatabaseDumpRequest {
+    /** Service name */
+    serviceName: string;
+    /** Database name */
+    databaseName: string;
+    /** Id */
+    id: number;
+}
+export declare const RestoreHostingPrivateDatabaseDatabaseDumpRequest: S.Schema<RestoreHostingPrivateDatabaseDatabaseDumpRequest>;
+export interface RestoreHostingPrivateDatabaseDumpRequest {
+    /** Service name */
+    serviceName: string;
+    /** Dump ID */
+    dumpId: number;
+    /** Database name */
+    databaseName?: string;
+}
+export declare const RestoreHostingPrivateDatabaseDumpRequest: S.Schema<RestoreHostingPrivateDatabaseDumpRequest>;
+export interface TerminateHostingPrivateDatabaseRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const TerminateHostingPrivateDatabaseRequest: S.Schema<TerminateHostingPrivateDatabaseRequest>;
+export type TerminateHostingPrivateDatabaseResponse = string;
+export declare const TerminateHostingPrivateDatabaseResponse: S.Schema<TerminateHostingPrivateDatabaseResponse>;
+/** ConfigKeyValue */
+export interface HostingPrivateDatabaseConfigKeyValue {
+    /** Web Cloud Database configuration key */
+    key: string;
+    /** Web Cloud Database configuration value */
+    value: string;
+}
+export declare const HostingPrivateDatabaseConfigKeyValue: S.Schema<HostingPrivateDatabaseConfigKeyValue>;
+/** Web Cloud Database configurations */
+export type UpdateHostingPrivateDatabaseConfigRequestParametersList = Array<HostingPrivateDatabaseConfigKeyValue>;
+export declare const UpdateHostingPrivateDatabaseConfigRequestParametersList: S.Schema<UpdateHostingPrivateDatabaseConfigRequestParametersList>;
+export interface UpdateHostingPrivateDatabaseConfigRequest {
+    /** Service name */
+    serviceName: string;
+    /** Web Cloud Database configurations */
+    parameters: UpdateHostingPrivateDatabaseConfigRequestParametersList;
+}
+export declare const UpdateHostingPrivateDatabaseConfigRequest: S.Schema<UpdateHostingPrivateDatabaseConfigRequest>;
+export interface UpdateHostingPrivateDatabaseUserGrantRequest {
+    /** Service name */
+    serviceName: string;
+    /** User name */
+    userName: string;
+    /** Database name */
+    databaseName: string;
+    /** Grant on a database for a specific user */
+    grant: HostingPrivateDatabaseGrantGrantEnum | (string & {});
+}
+export declare const UpdateHostingPrivateDatabaseUserGrantRequest: S.Schema<UpdateHostingPrivateDatabaseUserGrantRequest>;
+export type ConfirmHostingPrivateDatabaseTerminationError = OvhOpError;
+/** Confirm service termination */
+export declare const confirmHostingPrivateDatabaseTermination: API.OperationMethod<ConfirmHostingPrivateDatabaseTerminationRequest, ConfirmHostingPrivateDatabaseTerminationResponse, ConfirmHostingPrivateDatabaseTerminationError, OvhOpContext>;
+export type CopyHostingPrivateDatabaseDatabaseError = OvhOpError;
+/** Create a new database copy in a Web Cloud Database */
+export declare const copyHostingPrivateDatabaseDatabase: API.OperationMethod<CopyHostingPrivateDatabaseDatabaseRequest, HostingPrivateDatabaseDatabaseCopy, CopyHostingPrivateDatabaseDatabaseError, OvhOpContext>;
+export type CopyHostingPrivateDatabaseDatabaseRestoreError = OvhOpError;
+/** Request the copy into a Web Cloud Database */
+export declare const copyHostingPrivateDatabaseDatabaseRestore: API.OperationMethod<CopyHostingPrivateDatabaseDatabaseRestoreRequest, HostingPrivateDatabaseTask, CopyHostingPrivateDatabaseDatabaseRestoreError, OvhOpContext>;
+export type CreateHostingPrivateDatabaseChangeContactError = OvhOpError;
+/** Launch a contact change procedure */
+export declare const createHostingPrivateDatabaseChangeContact: API.OperationMethod<CreateHostingPrivateDatabaseChangeContactRequest, CreateHostingPrivateDatabaseChangeContactResponse, CreateHostingPrivateDatabaseChangeContactError, OvhOpContext>;
+export type CreateHostingPrivateDatabaseChangeFtpPasswordError = OvhOpError;
+/** Change FTP password of your Web Cloud Database */
+export declare const createHostingPrivateDatabaseChangeFtpPassword: API.OperationMethod<CreateHostingPrivateDatabaseChangeFtpPasswordRequest, HostingPrivateDatabaseTask, CreateHostingPrivateDatabaseChangeFtpPasswordError, OvhOpContext>;
+export type CreateHostingPrivateDatabaseChangeVersionError = OvhOpError;
+/** Change DBMS version of your Web Cloud Database */
+export declare const createHostingPrivateDatabaseChangeVersion: API.OperationMethod<CreateHostingPrivateDatabaseChangeVersionRequest, HostingPrivateDatabaseTask, CreateHostingPrivateDatabaseChangeVersionError, OvhOpContext>;
+export type CreateHostingPrivateDatabaseDatabaseError = OvhOpError;
+/** Create a new database in a Web Cloud Database */
+export declare const createHostingPrivateDatabaseDatabase: API.OperationMethod<CreateHostingPrivateDatabaseDatabaseRequest, HostingPrivateDatabaseTask, CreateHostingPrivateDatabaseDatabaseError, OvhOpContext>;
+export type CreateHostingPrivateDatabaseDatabaseDumpError = OvhOpError;
+/** Request the dump of this database (an email will be sent with a link available 30 days) */
+export declare const createHostingPrivateDatabaseDatabaseDump: API.OperationMethod<CreateHostingPrivateDatabaseDatabaseDumpRequest, HostingPrivateDatabaseTask, CreateHostingPrivateDatabaseDatabaseDumpError, OvhOpContext>;
+export type CreateHostingPrivateDatabaseDatabaseWizardError = OvhOpError;
+/** Create a new database/user and grant it */
+export declare const createHostingPrivateDatabaseDatabaseWizard: API.OperationMethod<CreateHostingPrivateDatabaseDatabaseWizardRequest, HostingPrivateDatabaseTask, CreateHostingPrivateDatabaseDatabaseWizardError, OvhOpContext>;
+export type CreateHostingPrivateDatabaseLogSubscriptionError = OvhOpError;
+/** Create subscription to log to customer for a Web Cloud Database */
+export declare const createHostingPrivateDatabaseLogSubscription: API.OperationMethod<CreateHostingPrivateDatabaseLogSubscriptionRequest, DbaasLogsLogSubscriptionResponse, CreateHostingPrivateDatabaseLogSubscriptionError, OvhOpContext>;
+export type CreateHostingPrivateDatabaseLogUrlError = OvhOpError;
+/** Generate a temporary URL to retrieve logs */
+export declare const createHostingPrivateDatabaseLogUrl: API.OperationMethod<CreateHostingPrivateDatabaseLogUrlRequest, DbaasLogsTemporaryLogsLink, CreateHostingPrivateDatabaseLogUrlError, OvhOpContext>;
+export type CreateHostingPrivateDatabaseQuotaRefreshError = OvhOpError;
+/** Refresh the quota of your Web Cloud Database */
+export declare const createHostingPrivateDatabaseQuotaRefresh: API.OperationMethod<CreateHostingPrivateDatabaseQuotaRefreshRequest, HostingPrivateDatabaseTask, CreateHostingPrivateDatabaseQuotaRefreshError, OvhOpContext>;
+export type CreateHostingPrivateDatabaseUserError = OvhOpError;
+/** Create a user on a Web Cloud Database */
+export declare const createHostingPrivateDatabaseUser: API.OperationMethod<CreateHostingPrivateDatabaseUserRequest, HostingPrivateDatabaseTask, CreateHostingPrivateDatabaseUserError, OvhOpContext>;
+export type CreateHostingPrivateDatabaseUserChangePasswordError = OvhOpError;
+/** Change the password of a user on a Web Cloud Database */
+export declare const createHostingPrivateDatabaseUserChangePassword: API.OperationMethod<CreateHostingPrivateDatabaseUserChangePasswordRequest, HostingPrivateDatabaseTask, CreateHostingPrivateDatabaseUserChangePasswordError, OvhOpContext>;
+export type CreateHostingPrivateDatabaseUserGrantError = OvhOpError;
+/** Add grant on a Web Cloud Database */
+export declare const createHostingPrivateDatabaseUserGrant: API.OperationMethod<CreateHostingPrivateDatabaseUserGrantRequest, HostingPrivateDatabaseTask, CreateHostingPrivateDatabaseUserGrantError, OvhOpContext>;
+export type CreateHostingPrivateDatabaseWebhostingNetworkError = OvhOpError;
+/** Permit access from the web hosting network on a Web Cloud Database */
+export declare const createHostingPrivateDatabaseWebhostingNetwork: API.OperationMethod<CreateHostingPrivateDatabaseWebhostingNetworkRequest, HostingPrivateDatabaseTask, CreateHostingPrivateDatabaseWebhostingNetworkError, OvhOpContext>;
+export type CreateHostingPrivateDatabaseWhitelistError = OvhOpError;
+/** Create a new IP whitelist in a Web Cloud Database */
+export declare const createHostingPrivateDatabaseWhitelist: API.OperationMethod<CreateHostingPrivateDatabaseWhitelistRequest, HostingPrivateDatabaseTask, CreateHostingPrivateDatabaseWhitelistError, OvhOpContext>;
+export type DeleteHostingPrivateDatabaseDatabaseError = OvhOpError;
+/** Delete a database from a Web Cloud Database */
+export declare const deleteHostingPrivateDatabaseDatabase: API.OperationMethod<DeleteHostingPrivateDatabaseDatabaseRequest, HostingPrivateDatabaseTask, DeleteHostingPrivateDatabaseDatabaseError, OvhOpContext>;
+export type DeleteHostingPrivateDatabaseDatabaseCopyError = OvhOpError;
+/** Delete the database copy of a Web Cloud Database */
+export declare const deleteHostingPrivateDatabaseDatabaseCopy: API.OperationMethod<DeleteHostingPrivateDatabaseDatabaseCopyRequest, DeleteHostingPrivateDatabaseDatabaseCopyResponse, DeleteHostingPrivateDatabaseDatabaseCopyError, OvhOpContext>;
+export type DeleteHostingPrivateDatabaseDatabaseDumpError = OvhOpError;
+/** Delete dump before expiration date */
+export declare const deleteHostingPrivateDatabaseDatabaseDump: API.OperationMethod<DeleteHostingPrivateDatabaseDatabaseDumpRequest, HostingPrivateDatabaseTask, DeleteHostingPrivateDatabaseDatabaseDumpError, OvhOpContext>;
+export type DeleteHostingPrivateDatabaseDumpError = OvhOpError;
+/** Delete a database dump from a Web Cloud Database */
+export declare const deleteHostingPrivateDatabaseDump: API.OperationMethod<DeleteHostingPrivateDatabaseDumpRequest, HostingPrivateDatabaseTask, DeleteHostingPrivateDatabaseDumpError, OvhOpContext>;
+export type DeleteHostingPrivateDatabaseLogSubscriptionError = OvhOpError;
+/** Delete a subscription */
+export declare const deleteHostingPrivateDatabaseLogSubscription: API.OperationMethod<DeleteHostingPrivateDatabaseLogSubscriptionRequest, DbaasLogsLogSubscriptionResponse, DeleteHostingPrivateDatabaseLogSubscriptionError, OvhOpContext>;
+export type DeleteHostingPrivateDatabaseUserError = OvhOpError;
+/** Delete a user on a Web Cloud Database */
+export declare const deleteHostingPrivateDatabaseUser: API.OperationMethod<DeleteHostingPrivateDatabaseUserRequest, HostingPrivateDatabaseTask, DeleteHostingPrivateDatabaseUserError, OvhOpContext>;
+export type DeleteHostingPrivateDatabaseUserGrantError = OvhOpError;
+/** Delete a grant from a Web Cloud Database */
+export declare const deleteHostingPrivateDatabaseUserGrant: API.OperationMethod<DeleteHostingPrivateDatabaseUserGrantRequest, HostingPrivateDatabaseTask, DeleteHostingPrivateDatabaseUserGrantError, OvhOpContext>;
+export type DeleteHostingPrivateDatabaseWebhostingNetworkError = OvhOpError;
+/** Delete access from the web hosting network on a Web Cloud Database */
+export declare const deleteHostingPrivateDatabaseWebhostingNetwork: API.OperationMethod<DeleteHostingPrivateDatabaseWebhostingNetworkRequest, HostingPrivateDatabaseTask, DeleteHostingPrivateDatabaseWebhostingNetworkError, OvhOpContext>;
+export type DeleteHostingPrivateDatabaseWhitelistError = OvhOpError;
+/** Delete an IP whitelist from a Web Cloud Database */
+export declare const deleteHostingPrivateDatabaseWhitelist: API.OperationMethod<DeleteHostingPrivateDatabaseWhitelistRequest, HostingPrivateDatabaseTask, DeleteHostingPrivateDatabaseWhitelistError, OvhOpContext>;
+export type DisableHostingPrivateDatabaseDatabaseExtensionError = OvhOpError;
+/** Disable an extension on a Web Cloud Database */
+export declare const disableHostingPrivateDatabaseDatabaseExtension: API.OperationMethod<DisableHostingPrivateDatabaseDatabaseExtensionRequest, HostingPrivateDatabaseTask, DisableHostingPrivateDatabaseDatabaseExtensionError, OvhOpContext>;
+export type EnableHostingPrivateDatabaseDatabaseExtensionError = OvhOpError;
+/** Enable an extension on a Web Cloud Database */
+export declare const enableHostingPrivateDatabaseDatabaseExtension: API.OperationMethod<EnableHostingPrivateDatabaseDatabaseExtensionRequest, HostingPrivateDatabaseTask, EnableHostingPrivateDatabaseDatabaseExtensionError, OvhOpContext>;
+export type GenerateHostingPrivateDatabaseTemporaryLogsLinkError = OvhOpError;
+/** Generate a temporary link to access logs for a Web Cloud Database */
+export declare const generateHostingPrivateDatabaseTemporaryLogsLink: API.OperationMethod<GenerateHostingPrivateDatabaseTemporaryLogsLinkRequest, HostingPrivateDatabaseTemporaryUrlInformations, GenerateHostingPrivateDatabaseTemporaryLogsLinkError, OvhOpContext>;
+export type GetHostingPrivateDatabaseError = OvhOpError;
+/** Get a Web Cloud Database properties */
+export declare const getHostingPrivateDatabase: API.OperationMethod<GetHostingPrivateDatabaseRequest, HostingPrivateDatabaseServiceWithIAM, GetHostingPrivateDatabaseError, OvhOpContext>;
+export type GetHostingPrivateDatabaseDatabaseError = OvhOpError;
+/** Get database properties */
+export declare const getHostingPrivateDatabaseDatabase: API.OperationMethod<GetHostingPrivateDatabaseDatabaseRequest, HostingPrivateDatabaseDatabase, GetHostingPrivateDatabaseDatabaseError, OvhOpContext>;
+export type GetHostingPrivateDatabaseDatabaseCopyError = OvhOpError;
+/** Get database copy properties */
+export declare const getHostingPrivateDatabaseDatabaseCopy: API.OperationMethod<GetHostingPrivateDatabaseDatabaseCopyRequest, HostingPrivateDatabaseDatabaseCopy, GetHostingPrivateDatabaseDatabaseCopyError, OvhOpContext>;
+export type GetHostingPrivateDatabaseDatabaseDumpError = OvhOpError;
+/** Get a database dump from a Web Cloud Database */
+export declare const getHostingPrivateDatabaseDatabaseDump: API.OperationMethod<GetHostingPrivateDatabaseDatabaseDumpRequest, HostingPrivateDatabaseDatabaseDump, GetHostingPrivateDatabaseDatabaseDumpError, OvhOpContext>;
+export type GetHostingPrivateDatabaseDatabaseExtensionError = OvhOpError;
+/** Get properties of a Webcloud Database extension */
+export declare const getHostingPrivateDatabaseDatabaseExtension: API.OperationMethod<GetHostingPrivateDatabaseDatabaseExtensionRequest, HostingPrivateDatabaseExtension, GetHostingPrivateDatabaseDatabaseExtensionError, OvhOpContext>;
+export type GetHostingPrivateDatabaseDumpError = OvhOpError;
+/** Get a database dump from a Web Cloud Database */
+export declare const getHostingPrivateDatabaseDump: API.OperationMethod<GetHostingPrivateDatabaseDumpRequest, HostingPrivateDatabaseDump, GetHostingPrivateDatabaseDumpError, OvhOpContext>;
+export type GetHostingPrivateDatabaseLogKindError = OvhOpError;
+/** Get a log kind */
+export declare const getHostingPrivateDatabaseLogKind: API.OperationMethod<GetHostingPrivateDatabaseLogKindRequest, DbaasLogsLogKind, GetHostingPrivateDatabaseLogKindError, OvhOpContext>;
+export type GetHostingPrivateDatabaseLogSubscriptionError = OvhOpError;
+/** Get subscription details */
+export declare const getHostingPrivateDatabaseLogSubscription: API.OperationMethod<GetHostingPrivateDatabaseLogSubscriptionRequest, DbaasLogsLogSubscription, GetHostingPrivateDatabaseLogSubscriptionError, OvhOpContext>;
+export type GetHostingPrivateDatabaseMetricsTokenError = OvhOpError;
+/** Generate a metrics token */
+export declare const getHostingPrivateDatabaseMetricsToken: API.OperationMethod<GetHostingPrivateDatabaseMetricsTokenRequest, HostingPrivateDatabaseMetricsToken, GetHostingPrivateDatabaseMetricsTokenError, OvhOpContext>;
+export type GetHostingPrivateDatabaseServiceInfosError = OvhOpError;
+/** Get service information */
+export declare const getHostingPrivateDatabaseServiceInfos: API.OperationMethod<GetHostingPrivateDatabaseServiceInfosRequest, ServicesService, GetHostingPrivateDatabaseServiceInfosError, OvhOpContext>;
+export type GetHostingPrivateDatabaseTaskError = OvhOpError;
+/** Get task details */
+export declare const getHostingPrivateDatabaseTask: API.OperationMethod<GetHostingPrivateDatabaseTaskRequest, HostingPrivateDatabaseTask, GetHostingPrivateDatabaseTaskError, OvhOpContext>;
+export type GetHostingPrivateDatabaseUserError = OvhOpError;
+/** Get user properties */
+export declare const getHostingPrivateDatabaseUser: API.OperationMethod<GetHostingPrivateDatabaseUserRequest, HostingPrivateDatabaseUser, GetHostingPrivateDatabaseUserError, OvhOpContext>;
+export type GetHostingPrivateDatabaseUserGrantError = OvhOpError;
+/** Get information about the grants for a user in a Web Cloud Database */
+export declare const getHostingPrivateDatabaseUserGrant: API.OperationMethod<GetHostingPrivateDatabaseUserGrantRequest, HostingPrivateDatabaseUserGrant, GetHostingPrivateDatabaseUserGrantError, OvhOpContext>;
+export type GetHostingPrivateDatabaseWebhostingNetworkError = OvhOpError;
+/** Get Webhosting network status */
+export declare const getHostingPrivateDatabaseWebhostingNetwork: API.OperationMethod<GetHostingPrivateDatabaseWebhostingNetworkRequest, HostingPrivateDatabaseWebhostingNetwork, GetHostingPrivateDatabaseWebhostingNetworkError, OvhOpContext>;
+export type GetHostingPrivateDatabaseWhitelistError = OvhOpError;
+/** Get whitelist properties */
+export declare const getHostingPrivateDatabaseWhitelist: API.OperationMethod<GetHostingPrivateDatabaseWhitelistRequest, HostingPrivateDatabaseWhitelist, GetHostingPrivateDatabaseWhitelistError, OvhOpContext>;
+export type ImportHostingPrivateDatabaseDatabaseError = OvhOpError;
+/** Import a database into a Web Cloud Database */
+export declare const importHostingPrivateDatabaseDatabase: API.OperationMethod<ImportHostingPrivateDatabaseDatabaseRequest, HostingPrivateDatabaseTask, ImportHostingPrivateDatabaseDatabaseError, OvhOpContext>;
+export type ListHostingPrivateDatabaseError = OvhOpError;
+/** List available Web Cloud Databases */
+export declare const listHostingPrivateDatabase: API.OperationMethod<ListHostingPrivateDatabaseRequest, ListHostingPrivateDatabaseResponse, ListHostingPrivateDatabaseError, OvhOpContext>;
+export type ListHostingPrivateDatabaseAvailableOrderCapacitiesError = OvhOpError;
+/** Get available order capacities */
+export declare const listHostingPrivateDatabaseAvailableOrderCapacities: API.OperationMethod<ListHostingPrivateDatabaseAvailableOrderCapacitiesRequest, HostingPrivateDatabaseAvailableOrderCapacities, ListHostingPrivateDatabaseAvailableOrderCapacitiesError, OvhOpContext>;
+export type ListHostingPrivateDatabaseAvailableVersionsError = OvhOpError;
+/** Get the availables versions for this private database */
+export declare const listHostingPrivateDatabaseAvailableVersions: API.OperationMethod<ListHostingPrivateDatabaseAvailableVersionsRequest, ListHostingPrivateDatabaseAvailableVersionsResponse, ListHostingPrivateDatabaseAvailableVersionsError, OvhOpContext>;
+export type ListHostingPrivateDatabaseConfigError = OvhOpError;
+/** Get the current configuration for this Web Cloud Database */
+export declare const listHostingPrivateDatabaseConfig: API.OperationMethod<ListHostingPrivateDatabaseConfigRequest, HostingPrivateDatabaseConfigs, ListHostingPrivateDatabaseConfigError, OvhOpContext>;
+export type ListHostingPrivateDatabaseCpuThrottleError = OvhOpError;
+/** List of privatesql CPU throttle */
+export declare const listHostingPrivateDatabaseCpuThrottle: API.OperationMethod<ListHostingPrivateDatabaseCpuThrottleRequest, ListHostingPrivateDatabaseCpuThrottleResponse, ListHostingPrivateDatabaseCpuThrottleError, OvhOpContext>;
+export type ListHostingPrivateDatabaseDatabaseError = OvhOpError;
+/** List databases on a privateDatabase */
+export declare const listHostingPrivateDatabaseDatabase: API.OperationMethod<ListHostingPrivateDatabaseDatabaseRequest, ListHostingPrivateDatabaseDatabaseResponse, ListHostingPrivateDatabaseDatabaseError, OvhOpContext>;
+export type ListHostingPrivateDatabaseDatabaseCopyError = OvhOpError;
+/** List database copy of a privateDatabase */
+export declare const listHostingPrivateDatabaseDatabaseCopy: API.OperationMethod<ListHostingPrivateDatabaseDatabaseCopyRequest, ListHostingPrivateDatabaseDatabaseCopyResponse, ListHostingPrivateDatabaseDatabaseCopyError, OvhOpContext>;
+export type ListHostingPrivateDatabaseDatabaseDumpError = OvhOpError;
+/** Get all database dump from a Web Cloud Database */
+export declare const listHostingPrivateDatabaseDatabaseDump: API.OperationMethod<ListHostingPrivateDatabaseDatabaseDumpRequest, ListHostingPrivateDatabaseDatabaseDumpResponse, ListHostingPrivateDatabaseDatabaseDumpError, OvhOpContext>;
+export type ListHostingPrivateDatabaseDatabaseExtensionError = OvhOpError;
+/** List extensions available for a Webcloud Database */
+export declare const listHostingPrivateDatabaseDatabaseExtension: API.OperationMethod<ListHostingPrivateDatabaseDatabaseExtensionRequest, ListHostingPrivateDatabaseDatabaseExtensionResponse, ListHostingPrivateDatabaseDatabaseExtensionError, OvhOpContext>;
+export type ListHostingPrivateDatabaseDumpError = OvhOpError;
+/** Get all database dump from a Web Cloud Database */
+export declare const listHostingPrivateDatabaseDump: API.OperationMethod<ListHostingPrivateDatabaseDumpRequest, ListHostingPrivateDatabaseDumpResponse, ListHostingPrivateDatabaseDumpError, OvhOpContext>;
+export type ListHostingPrivateDatabaseLogKindError = OvhOpError;
+/** List available log kinds */
+export declare const listHostingPrivateDatabaseLogKind: API.OperationMethod<ListHostingPrivateDatabaseLogKindRequest, ListHostingPrivateDatabaseLogKindResponse, ListHostingPrivateDatabaseLogKindError, OvhOpContext>;
+export type ListHostingPrivateDatabaseLogSubscriptionError = OvhOpError;
+/** List subscription IDs for Web Cloud Database */
+export declare const listHostingPrivateDatabaseLogSubscription: API.OperationMethod<ListHostingPrivateDatabaseLogSubscriptionRequest, ListHostingPrivateDatabaseLogSubscriptionResponse, ListHostingPrivateDatabaseLogSubscriptionError, OvhOpContext>;
+export type ListHostingPrivateDatabaseOomError = OvhOpError;
+/** List of privatesql OOM kill */
+export declare const listHostingPrivateDatabaseOom: API.OperationMethod<ListHostingPrivateDatabaseOomRequest, ListHostingPrivateDatabaseOomResponse, ListHostingPrivateDatabaseOomError, OvhOpContext>;
+export type ListHostingPrivateDatabaseTasksError = OvhOpError;
+/** List tasks for a Webcloud Database */
+export declare const listHostingPrivateDatabaseTasks: API.OperationMethod<ListHostingPrivateDatabaseTasksRequest, ListHostingPrivateDatabaseTasksResponse, ListHostingPrivateDatabaseTasksError, OvhOpContext>;
+export type ListHostingPrivateDatabaseUserError = OvhOpError;
+/** List users on a Web Cloud Database */
+export declare const listHostingPrivateDatabaseUser: API.OperationMethod<ListHostingPrivateDatabaseUserRequest, ListHostingPrivateDatabaseUserResponse, ListHostingPrivateDatabaseUserError, OvhOpContext>;
+export type ListHostingPrivateDatabaseUserGrantError = OvhOpError;
+/** Get all information about the grants for a user in a Web Cloud Database */
+export declare const listHostingPrivateDatabaseUserGrant: API.OperationMethod<ListHostingPrivateDatabaseUserGrantRequest, ListHostingPrivateDatabaseUserGrantResponse, ListHostingPrivateDatabaseUserGrantError, OvhOpContext>;
+export type ListHostingPrivateDatabaseWebsError = OvhOpError;
+/** List linked webs */
+export declare const listHostingPrivateDatabaseWebs: API.OperationMethod<ListHostingPrivateDatabaseWebsRequest, ListHostingPrivateDatabaseWebsResponse, ListHostingPrivateDatabaseWebsError, OvhOpContext>;
+export type ListHostingPrivateDatabaseWhitelistError = OvhOpError;
+/** List whitelists on a Web Cloud Database */
+export declare const listHostingPrivateDatabaseWhitelist: API.OperationMethod<ListHostingPrivateDatabaseWhitelistRequest, ListHostingPrivateDatabaseWhitelistResponse, ListHostingPrivateDatabaseWhitelistError, OvhOpContext>;
+export type PutHostingPrivateDatabaseError = OvhOpError;
+/** Alter a Web Cloud Database properties */
+export declare const putHostingPrivateDatabase: API.OperationMethod<PutHostingPrivateDatabaseRequest, PutHostingPrivateDatabaseResponse, PutHostingPrivateDatabaseError, OvhOpContext>;
+export type PutHostingPrivateDatabaseServiceInfosError = OvhOpError;
+/** Update service information */
+export declare const putHostingPrivateDatabaseServiceInfos: API.OperationMethod<PutHostingPrivateDatabaseServiceInfosRequest, PutHostingPrivateDatabaseServiceInfosResponse, PutHostingPrivateDatabaseServiceInfosError, OvhOpContext>;
+export type PutHostingPrivateDatabaseWhitelistError = OvhOpError;
+/** Update an IP whitelist in a Web Cloud Database */
+export declare const putHostingPrivateDatabaseWhitelist: API.OperationMethod<PutHostingPrivateDatabaseWhitelistRequest, PutHostingPrivateDatabaseWhitelistResponse, PutHostingPrivateDatabaseWhitelistError, OvhOpContext>;
+export type RestartHostingPrivateDatabaseError = OvhOpError;
+/** Restart the Web Cloud Database */
+export declare const restartHostingPrivateDatabase: API.OperationMethod<RestartHostingPrivateDatabaseRequest, HostingPrivateDatabaseTask, RestartHostingPrivateDatabaseError, OvhOpContext>;
+export type RestoreHostingPrivateDatabaseDatabaseDumpError = OvhOpError;
+/** Request the restore from this dump */
+export declare const restoreHostingPrivateDatabaseDatabaseDump: API.OperationMethod<RestoreHostingPrivateDatabaseDatabaseDumpRequest, HostingPrivateDatabaseTask, RestoreHostingPrivateDatabaseDatabaseDumpError, OvhOpContext>;
+export type RestoreHostingPrivateDatabaseDumpError = OvhOpError;
+/** Restore a database dump into a Web Cloud Database */
+export declare const restoreHostingPrivateDatabaseDump: API.OperationMethod<RestoreHostingPrivateDatabaseDumpRequest, HostingPrivateDatabaseTask, RestoreHostingPrivateDatabaseDumpError, OvhOpContext>;
+export type TerminateHostingPrivateDatabaseError = OvhOpError;
+/** Ask for the termination of your service */
+export declare const terminateHostingPrivateDatabase: API.OperationMethod<TerminateHostingPrivateDatabaseRequest, TerminateHostingPrivateDatabaseResponse, TerminateHostingPrivateDatabaseError, OvhOpContext>;
+export type UpdateHostingPrivateDatabaseConfigError = OvhOpError;
+/** Update the configuration of this Web Cloud Database */
+export declare const updateHostingPrivateDatabaseConfig: API.OperationMethod<UpdateHostingPrivateDatabaseConfigRequest, HostingPrivateDatabaseConfigs, UpdateHostingPrivateDatabaseConfigError, OvhOpContext>;
+export type UpdateHostingPrivateDatabaseUserGrantError = OvhOpError;
+/** Update the permissions of a grant for a user on a Web Cloud Database */
+export declare const updateHostingPrivateDatabaseUserGrant: API.OperationMethod<UpdateHostingPrivateDatabaseUserGrantRequest, HostingPrivateDatabaseTask, UpdateHostingPrivateDatabaseUserGrantError, OvhOpContext>;
+//# sourceMappingURL=hostingprivatedatabase.d.ts.map