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

package/src/services/hostingprivatedatabase.ts

@@ -0,0 +1,4218 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-ovh). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as Redacted from "effect/Redacted";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  OvhProtocol,
+  type OvhOpError,
+  type OvhOpContext,
+} from "../protocol.ts";
+import { UnknownOvhError } from "../errors.ts";
+import * as Retry from "../retry.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 const ServiceTerminationFutureUseEnum = /*@__PURE__*/ S.String;
+
+/** 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 const ServiceTerminationReasonEnum = /*@__PURE__*/ S.String;
+
+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 const ConfirmHostingPrivateDatabaseTerminationRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      commentary: S.optional(S.String),
+      futureUse: S.optional(ServiceTerminationFutureUseEnum),
+      reason: S.optional(ServiceTerminationReasonEnum),
+      token: S.String,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/confirmTermination",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ConfirmHostingPrivateDatabaseTerminationRequest",
+  }) as any as S.Schema<ConfirmHostingPrivateDatabaseTerminationRequest>;
+
+export type ConfirmHostingPrivateDatabaseTerminationResponse = string;
+export const ConfirmHostingPrivateDatabaseTerminationResponse =
+  /*@__PURE__*/ S.suspend(() => S.String.pipe(T.RawResponseRoot())).annotate({
+    identifier: "ConfirmHostingPrivateDatabaseTerminationResponse",
+  }) as any as S.Schema<ConfirmHostingPrivateDatabaseTerminationResponse>;
+
+export interface CopyHostingPrivateDatabaseDatabaseRequest {
+  /** Service name */
+  serviceName: string;
+  /** Database name */
+  databaseName: string;
+}
+export const CopyHostingPrivateDatabaseDatabaseRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      databaseName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/database/{databaseName}/copy",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CopyHostingPrivateDatabaseDatabaseRequest",
+  }) as any as S.Schema<CopyHostingPrivateDatabaseDatabaseRequest>;
+
+/** Database copy status */
+export type HostingPrivateDatabaseDatabaseCopyStatusEnum =
+  | "doing"
+  | "done"
+  | "error"
+  | "todo";
+export const HostingPrivateDatabaseDatabaseCopyStatusEnum =
+  /*@__PURE__*/ S.String;
+
+/** 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 const HostingPrivateDatabaseDatabaseCopy = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    creationDate: S.optional(S.String),
+    expirationDate: S.optional(S.NullOr(S.String)),
+    id: S.optional(S.String),
+    lastUpdate: S.optional(S.String),
+    status: S.optional(HostingPrivateDatabaseDatabaseCopyStatusEnum),
+  }),
+).annotate({
+  identifier: "HostingPrivateDatabaseDatabaseCopy",
+}) as any as 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 const CopyHostingPrivateDatabaseDatabaseRestoreRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      databaseName: S.String.pipe(T.Label()),
+      copyId: S.String,
+      flushDatabase: S.optional(S.Boolean),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/database/{databaseName}/copyRestore",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CopyHostingPrivateDatabaseDatabaseRestoreRequest",
+  }) as any as 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 const HostingPrivateDatabaseTaskFunctionEnum = /*@__PURE__*/ S.String;
+
+/** Task's status */
+export type HostingPrivateDatabaseTaskStatusEnum =
+  | "cancelled"
+  | "doing"
+  | "done"
+  | "error"
+  | "todo";
+export const HostingPrivateDatabaseTaskStatusEnum = /*@__PURE__*/ S.String;
+
+/** 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 const HostingPrivateDatabaseTask = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    databaseName: S.optional(S.NullOr(S.String)),
+    doneDate: S.optional(S.NullOr(S.String)),
+    dumpId: S.optional(S.NullOr(S.Number)),
+    function: S.optional(HostingPrivateDatabaseTaskFunctionEnum),
+    id: S.optional(S.Number),
+    lastUpdate: S.optional(S.NullOr(S.String)),
+    startDate: S.optional(S.String),
+    status: S.optional(HostingPrivateDatabaseTaskStatusEnum),
+    userName: S.optional(S.NullOr(S.String)),
+  }),
+).annotate({
+  identifier: "HostingPrivateDatabaseTask",
+}) as any as 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 const CreateHostingPrivateDatabaseChangeContactRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      contactAdmin: S.optional(S.String),
+      contactBilling: S.optional(S.String),
+      contactTech: S.optional(S.String),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/changeContact",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateHostingPrivateDatabaseChangeContactRequest",
+  }) as any as S.Schema<CreateHostingPrivateDatabaseChangeContactRequest>;
+
+export type CreateHostingPrivateDatabaseChangeContactResponseBodyList =
+  Array<number>;
+export const CreateHostingPrivateDatabaseChangeContactResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.Number,
+  ) as any as S.Schema<CreateHostingPrivateDatabaseChangeContactResponseBodyList>;
+
+export type CreateHostingPrivateDatabaseChangeContactResponse =
+  CreateHostingPrivateDatabaseChangeContactResponseBodyList;
+export const CreateHostingPrivateDatabaseChangeContactResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    CreateHostingPrivateDatabaseChangeContactResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "CreateHostingPrivateDatabaseChangeContactResponse",
+  }) as any as 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 const CreateHostingPrivateDatabaseChangeFtpPasswordRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      password: S.String.pipe(T.SensitiveValue({})),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/changeFtpPassword",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateHostingPrivateDatabaseChangeFtpPasswordRequest",
+  }) as any as 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 const HostingPrivateDatabaseAvailableVersionEnum =
+  /*@__PURE__*/ S.String;
+
+export interface CreateHostingPrivateDatabaseChangeVersionRequest {
+  /** Service name */
+  serviceName: string;
+  /** Change the private database engine version */
+  version: HostingPrivateDatabaseAvailableVersionEnum | (string & {});
+}
+export const CreateHostingPrivateDatabaseChangeVersionRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      version: HostingPrivateDatabaseAvailableVersionEnum,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/changeVersion",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateHostingPrivateDatabaseChangeVersionRequest",
+  }) as any as S.Schema<CreateHostingPrivateDatabaseChangeVersionRequest>;
+
+export interface CreateHostingPrivateDatabaseDatabaseRequest {
+  /** Service name */
+  serviceName: string;
+  /** Name of your new database */
+  databaseName: string;
+}
+export const CreateHostingPrivateDatabaseDatabaseRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      databaseName: S.String,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/database",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateHostingPrivateDatabaseDatabaseRequest",
+  }) as any as 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 const CreateHostingPrivateDatabaseDatabaseDumpRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      databaseName: S.String.pipe(T.Label()),
+      sendEmail: S.optional(S.Boolean),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/database/{databaseName}/dump",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateHostingPrivateDatabaseDatabaseDumpRequest",
+  }) as any as S.Schema<CreateHostingPrivateDatabaseDatabaseDumpRequest>;
+
+/** Grant on a database for a specific user */
+export type HostingPrivateDatabaseGrantGrantEnum =
+  | "admin"
+  | "none"
+  | "ro"
+  | "rw";
+export const HostingPrivateDatabaseGrantGrantEnum = /*@__PURE__*/ S.String;
+
+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 const CreateHostingPrivateDatabaseDatabaseWizardRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      databaseName: S.String,
+      grant: HostingPrivateDatabaseGrantGrantEnum,
+      password: S.String.pipe(T.SensitiveValue({})),
+      userName: S.String,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/databaseWizard",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateHostingPrivateDatabaseDatabaseWizardRequest",
+  }) as any as 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 const CreateHostingPrivateDatabaseLogSubscriptionRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      kind: S.String,
+      streamId: S.String,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/log/subscription",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateHostingPrivateDatabaseLogSubscriptionRequest",
+  }) as any as 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 const DbaasLogsLogSubscriptionResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    operationId: S.optional(S.String),
+    serviceName: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "DbaasLogsLogSubscriptionResponse",
+}) as any as S.Schema<DbaasLogsLogSubscriptionResponse>;
+
+export interface CreateHostingPrivateDatabaseLogUrlRequest {
+  /** Service name */
+  serviceName: string;
+  /** Log kind name */
+  kind: string;
+}
+export const CreateHostingPrivateDatabaseLogUrlRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      kind: S.String,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/log/url",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateHostingPrivateDatabaseLogUrlRequest",
+  }) as any as S.Schema<CreateHostingPrivateDatabaseLogUrlRequest>;
+
+/** Temporary url information */
+export interface DbaasLogsTemporaryLogsLink {
+  /** Temporary url expiration date */
+  expirationDate?: string;
+  /** Temporary url */
+  url?: string;
+}
+export const DbaasLogsTemporaryLogsLink = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    expirationDate: S.optional(S.String),
+    url: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "DbaasLogsTemporaryLogsLink",
+}) as any as S.Schema<DbaasLogsTemporaryLogsLink>;
+
+export interface CreateHostingPrivateDatabaseQuotaRefreshRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const CreateHostingPrivateDatabaseQuotaRefreshRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/quotaRefresh",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateHostingPrivateDatabaseQuotaRefreshRequest",
+  }) as any as 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 const CreateHostingPrivateDatabaseUserRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      password: S.String.pipe(T.SensitiveValue({})),
+      userName: S.String,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/user",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "CreateHostingPrivateDatabaseUserRequest",
+}) as any as 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 const CreateHostingPrivateDatabaseUserChangePasswordRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      userName: S.String.pipe(T.Label()),
+      password: S.String.pipe(T.SensitiveValue({})),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/user/{userName}/changePassword",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateHostingPrivateDatabaseUserChangePasswordRequest",
+  }) as any as 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 const CreateHostingPrivateDatabaseUserGrantRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      userName: S.String.pipe(T.Label()),
+      databaseName: S.String,
+      grant: HostingPrivateDatabaseGrantGrantEnum,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/user/{userName}/grant",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateHostingPrivateDatabaseUserGrantRequest",
+  }) as any as S.Schema<CreateHostingPrivateDatabaseUserGrantRequest>;
+
+export interface CreateHostingPrivateDatabaseWebhostingNetworkRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const CreateHostingPrivateDatabaseWebhostingNetworkRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/webhostingNetwork",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateHostingPrivateDatabaseWebhostingNetworkRequest",
+  }) as any as 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 const CreateHostingPrivateDatabaseWhitelistRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      ip: S.String,
+      name: S.optional(S.NullOr(S.String)),
+      service: S.optional(S.Boolean),
+      sftp: S.optional(S.Boolean),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/whitelist",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateHostingPrivateDatabaseWhitelistRequest",
+  }) as any as S.Schema<CreateHostingPrivateDatabaseWhitelistRequest>;
+
+export interface DeleteHostingPrivateDatabaseDatabaseRequest {
+  /** Service name */
+  serviceName: string;
+  /** Database name */
+  databaseName: string;
+}
+export const DeleteHostingPrivateDatabaseDatabaseRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      databaseName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/hosting/privateDatabase/{serviceName}/database/{databaseName}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "DeleteHostingPrivateDatabaseDatabaseRequest",
+  }) as any as S.Schema<DeleteHostingPrivateDatabaseDatabaseRequest>;
+
+export interface DeleteHostingPrivateDatabaseDatabaseCopyRequest {
+  /** Service name */
+  serviceName: string;
+  /** Database name */
+  databaseName: string;
+  /** Id */
+  id: string;
+}
+export const DeleteHostingPrivateDatabaseDatabaseCopyRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      databaseName: S.String.pipe(T.Label()),
+      id: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/hosting/privateDatabase/{serviceName}/database/{databaseName}/copy/{id}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "DeleteHostingPrivateDatabaseDatabaseCopyRequest",
+  }) as any as S.Schema<DeleteHostingPrivateDatabaseDatabaseCopyRequest>;
+
+export interface DeleteHostingPrivateDatabaseDatabaseCopyResponse {}
+export const DeleteHostingPrivateDatabaseDatabaseCopyResponse =
+  /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "DeleteHostingPrivateDatabaseDatabaseCopyResponse",
+  }) as any as S.Schema<DeleteHostingPrivateDatabaseDatabaseCopyResponse>;
+
+export interface DeleteHostingPrivateDatabaseDatabaseDumpRequest {
+  /** Service name */
+  serviceName: string;
+  /** Database name */
+  databaseName: string;
+  /** Id */
+  id: number;
+}
+export const DeleteHostingPrivateDatabaseDatabaseDumpRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      databaseName: S.String.pipe(T.Label()),
+      id: S.Number.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/hosting/privateDatabase/{serviceName}/database/{databaseName}/dump/{id}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "DeleteHostingPrivateDatabaseDatabaseDumpRequest",
+  }) as any as S.Schema<DeleteHostingPrivateDatabaseDatabaseDumpRequest>;
+
+export interface DeleteHostingPrivateDatabaseDumpRequest {
+  /** Service name */
+  serviceName: string;
+  /** Dump ID */
+  dumpId: number;
+}
+export const DeleteHostingPrivateDatabaseDumpRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      dumpId: S.Number.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/hosting/privateDatabase/{serviceName}/dump/{dumpId}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "DeleteHostingPrivateDatabaseDumpRequest",
+}) as any as S.Schema<DeleteHostingPrivateDatabaseDumpRequest>;
+
+export interface DeleteHostingPrivateDatabaseLogSubscriptionRequest {
+  /** Service name */
+  serviceName: string;
+  /** Subscription ID */
+  subscriptionId: string;
+}
+export const DeleteHostingPrivateDatabaseLogSubscriptionRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      subscriptionId: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/hosting/privateDatabase/{serviceName}/log/subscription/{subscriptionId}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "DeleteHostingPrivateDatabaseLogSubscriptionRequest",
+  }) as any as S.Schema<DeleteHostingPrivateDatabaseLogSubscriptionRequest>;
+
+export interface DeleteHostingPrivateDatabaseUserRequest {
+  /** Service name */
+  serviceName: string;
+  /** User name */
+  userName: string;
+}
+export const DeleteHostingPrivateDatabaseUserRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      userName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/hosting/privateDatabase/{serviceName}/user/{userName}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "DeleteHostingPrivateDatabaseUserRequest",
+}) as any as S.Schema<DeleteHostingPrivateDatabaseUserRequest>;
+
+export interface DeleteHostingPrivateDatabaseUserGrantRequest {
+  /** Service name */
+  serviceName: string;
+  /** User name */
+  userName: string;
+  /** Database name */
+  databaseName: string;
+}
+export const DeleteHostingPrivateDatabaseUserGrantRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      userName: S.String.pipe(T.Label()),
+      databaseName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/hosting/privateDatabase/{serviceName}/user/{userName}/grant/{databaseName}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "DeleteHostingPrivateDatabaseUserGrantRequest",
+  }) as any as S.Schema<DeleteHostingPrivateDatabaseUserGrantRequest>;
+
+export interface DeleteHostingPrivateDatabaseWebhostingNetworkRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const DeleteHostingPrivateDatabaseWebhostingNetworkRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/hosting/privateDatabase/{serviceName}/webhostingNetwork",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "DeleteHostingPrivateDatabaseWebhostingNetworkRequest",
+  }) as any as S.Schema<DeleteHostingPrivateDatabaseWebhostingNetworkRequest>;
+
+export interface DeleteHostingPrivateDatabaseWhitelistRequest {
+  /** Service name */
+  serviceName: string;
+  /** Ip */
+  ip: string;
+}
+export const DeleteHostingPrivateDatabaseWhitelistRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      ip: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/hosting/privateDatabase/{serviceName}/whitelist/{ip}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "DeleteHostingPrivateDatabaseWhitelistRequest",
+  }) as any as S.Schema<DeleteHostingPrivateDatabaseWhitelistRequest>;
+
+export interface DisableHostingPrivateDatabaseDatabaseExtensionRequest {
+  /** Service name */
+  serviceName: string;
+  /** Database name */
+  databaseName: string;
+  /** Extension name */
+  extensionName: string;
+}
+export const DisableHostingPrivateDatabaseDatabaseExtensionRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      databaseName: S.String.pipe(T.Label()),
+      extensionName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/database/{databaseName}/extension/{extensionName}/disable",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "DisableHostingPrivateDatabaseDatabaseExtensionRequest",
+  }) as any as S.Schema<DisableHostingPrivateDatabaseDatabaseExtensionRequest>;
+
+export interface EnableHostingPrivateDatabaseDatabaseExtensionRequest {
+  /** Service name */
+  serviceName: string;
+  /** Database name */
+  databaseName: string;
+  /** Extension name */
+  extensionName: string;
+}
+export const EnableHostingPrivateDatabaseDatabaseExtensionRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      databaseName: S.String.pipe(T.Label()),
+      extensionName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/database/{databaseName}/extension/{extensionName}/enable",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "EnableHostingPrivateDatabaseDatabaseExtensionRequest",
+  }) as any as S.Schema<EnableHostingPrivateDatabaseDatabaseExtensionRequest>;
+
+export interface GenerateHostingPrivateDatabaseTemporaryLogsLinkRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const GenerateHostingPrivateDatabaseTemporaryLogsLinkRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/generateTemporaryLogsLink",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GenerateHostingPrivateDatabaseTemporaryLogsLinkRequest",
+  }) as any as S.Schema<GenerateHostingPrivateDatabaseTemporaryLogsLinkRequest>;
+
+/** Temporary url information */
+export interface HostingPrivateDatabaseTemporaryUrlInformations {
+  /** Temporary url expiration date */
+  expirationDate?: string;
+  /** Temporary url */
+  url?: string;
+}
+export const HostingPrivateDatabaseTemporaryUrlInformations =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      expirationDate: S.optional(S.String),
+      url: S.optional(S.String),
+    }),
+  ).annotate({
+    identifier: "HostingPrivateDatabaseTemporaryUrlInformations",
+  }) as any as S.Schema<HostingPrivateDatabaseTemporaryUrlInformations>;
+
+export interface GetHostingPrivateDatabaseRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const GetHostingPrivateDatabaseRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/hosting/privateDatabase/{serviceName}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetHostingPrivateDatabaseRequest",
+}) as any as 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 const HostingPrivateDatabaseCapability = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    create: S.optional(S.Boolean),
+    delete: S.optional(S.Boolean),
+    object: S.optional(S.String),
+    update: S.optional(S.Boolean),
+  }),
+).annotate({
+  identifier: "HostingPrivateDatabaseCapability",
+}) as any as S.Schema<HostingPrivateDatabaseCapability>;
+
+/** Private database capabilities */
+export type HostingPrivateDatabaseServiceWithIAMCapabilitiesList =
+  Array<HostingPrivateDatabaseCapability>;
+export const HostingPrivateDatabaseServiceWithIAMCapabilitiesList =
+  /*@__PURE__*/ S.Array(
+    HostingPrivateDatabaseCapability,
+  ) as any as S.Schema<HostingPrivateDatabaseServiceWithIAMCapabilitiesList>;
+
+/** Private database datacenter */
+export type HostingPrivateDatabaseDatacenterEnum =
+  | "bhs1"
+  | "gra1"
+  | "gra2"
+  | "gra3";
+export const HostingPrivateDatabaseDatacenterEnum = /*@__PURE__*/ S.String;
+
+/** 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 const HostingPrivateDatabaseGraphEndpoint = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    host: S.optional(S.NullOr(S.String)),
+    readToken: S.optional(S.NullOr(S.String)),
+    readTokenId: S.optional(S.NullOr(S.String)),
+  }),
+).annotate({
+  identifier: "HostingPrivateDatabaseGraphEndpoint",
+}) as any as S.Schema<HostingPrivateDatabaseGraphEndpoint>;
+
+/** Resource tags. Tags that were internally computed are prefixed with ovh: */
+export type IamResourceMetadataTagsMap = { [key: string]: string | undefined };
+export const IamResourceMetadataTagsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as 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 const IamResourceMetadata = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    displayName: S.optional(S.NullOr(S.String)),
+    id: S.optional(S.String),
+    tags: S.optional(S.NullOr(IamResourceMetadataTagsMap)),
+    urn: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "IamResourceMetadata",
+}) as any as S.Schema<IamResourceMetadata>;
+
+/** Private database infrastructure */
+export type HostingPrivateDatabaseInfrastructureEnum = "docker";
+export const HostingPrivateDatabaseInfrastructureEnum = /*@__PURE__*/ S.String;
+
+/** Available offers */
+export type HostingPrivateDatabaseOfferEnum = "classic" | "public";
+export const HostingPrivateDatabaseOfferEnum = /*@__PURE__*/ S.String;
+
+/** A numeric value tagged with its unit */
+export interface ComplexTypeUnitAndValueLong {
+  /** Unit of the value */
+  unit?: string;
+  value?: number;
+}
+export const ComplexTypeUnitAndValueLong = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    unit: S.optional(S.String),
+    value: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "ComplexTypeUnitAndValueLong",
+}) as any as S.Schema<ComplexTypeUnitAndValueLong>;
+
+/** Private database state */
+export type HostingPrivateDatabaseStateEnum =
+  | "detached"
+  | "restartPending"
+  | "startPending"
+  | "started"
+  | "stopPending"
+  | "stopped";
+export const HostingPrivateDatabaseStateEnum = /*@__PURE__*/ S.String;
+
+/** Private database type */
+export type HostingPrivateDatabaseTypeEnum =
+  | "mariadb"
+  | "mysql"
+  | "postgresql"
+  | "redis";
+export const HostingPrivateDatabaseTypeEnum = /*@__PURE__*/ S.String;
+
+/** 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 const HostingPrivateDatabaseVersionEnum = /*@__PURE__*/ S.String;
+
+/** 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 const HostingPrivateDatabaseServiceWithIAM = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      capabilities: S.optional(
+        HostingPrivateDatabaseServiceWithIAMCapabilitiesList,
+      ),
+      cpu: S.optional(S.Number),
+      datacenter: S.optional(HostingPrivateDatabaseDatacenterEnum),
+      displayName: S.optional(S.NullOr(S.String)),
+      graphEndpoint: S.optional(S.NullOr(HostingPrivateDatabaseGraphEndpoint)),
+      guiURL: S.optional(S.NullOr(S.String)),
+      hostname: S.optional(S.String),
+      hostnameFtp: S.optional(S.NullOr(S.String)),
+      iam: S.optional(S.NullOr(IamResourceMetadata)),
+      infrastructure: S.optional(HostingPrivateDatabaseInfrastructureEnum),
+      ip: S.optional(S.NullOr(S.String)),
+      lastCheck: S.optional(S.String),
+      offer: S.optional(HostingPrivateDatabaseOfferEnum),
+      port: S.optional(S.Number),
+      portFtp: S.optional(S.NullOr(S.Number)),
+      quotaSize: S.optional(ComplexTypeUnitAndValueLong),
+      quotaUsed: S.optional(ComplexTypeUnitAndValueLong),
+      ram: S.optional(ComplexTypeUnitAndValueLong),
+      server: S.optional(S.String),
+      serviceName: S.optional(S.String),
+      state: S.optional(HostingPrivateDatabaseStateEnum),
+      tlsCa: S.optional(S.NullOr(S.String)),
+      type: S.optional(HostingPrivateDatabaseTypeEnum),
+      version: S.optional(HostingPrivateDatabaseVersionEnum),
+      versionLabel: S.optional(S.String),
+      versionNumber: S.optional(S.Number),
+    }),
+).annotate({
+  identifier: "HostingPrivateDatabaseServiceWithIAM",
+}) as any as S.Schema<HostingPrivateDatabaseServiceWithIAM>;
+
+export interface GetHostingPrivateDatabaseDatabaseRequest {
+  /** Service name */
+  serviceName: string;
+  /** Database name */
+  databaseName: string;
+}
+export const GetHostingPrivateDatabaseDatabaseRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      databaseName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/database/{databaseName}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetHostingPrivateDatabaseDatabaseRequest",
+}) as any as 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 const HostingPrivateDatabaseDatabaseUser = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    grantId: S.optional(S.Number),
+    grantType: S.optional(HostingPrivateDatabaseGrantGrantEnum),
+    userName: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "HostingPrivateDatabaseDatabaseUser",
+}) as any as S.Schema<HostingPrivateDatabaseDatabaseUser>;
+
+/** Users granted to this database */
+export type HostingPrivateDatabaseDatabaseUsersList =
+  Array<HostingPrivateDatabaseDatabaseUser>;
+export const HostingPrivateDatabaseDatabaseUsersList = /*@__PURE__*/ S.Array(
+  HostingPrivateDatabaseDatabaseUser,
+) as any as 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 const HostingPrivateDatabaseDatabase = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    backupTime: S.optional(S.NullOr(S.String)),
+    creationDate: S.optional(S.String),
+    databaseName: S.optional(S.String),
+    quotaUsed: S.optional(ComplexTypeUnitAndValueLong),
+    users: S.optional(HostingPrivateDatabaseDatabaseUsersList),
+  }),
+).annotate({
+  identifier: "HostingPrivateDatabaseDatabase",
+}) as any as S.Schema<HostingPrivateDatabaseDatabase>;
+
+export interface GetHostingPrivateDatabaseDatabaseCopyRequest {
+  /** Service name */
+  serviceName: string;
+  /** Database name */
+  databaseName: string;
+  /** Id */
+  id: string;
+}
+export const GetHostingPrivateDatabaseDatabaseCopyRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      databaseName: S.String.pipe(T.Label()),
+      id: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/database/{databaseName}/copy/{id}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GetHostingPrivateDatabaseDatabaseCopyRequest",
+  }) as any as S.Schema<GetHostingPrivateDatabaseDatabaseCopyRequest>;
+
+export interface GetHostingPrivateDatabaseDatabaseDumpRequest {
+  /** Service name */
+  serviceName: string;
+  /** Database name */
+  databaseName: string;
+  /** Id */
+  id: number;
+}
+export const GetHostingPrivateDatabaseDatabaseDumpRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      databaseName: S.String.pipe(T.Label()),
+      id: S.Number.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/database/{databaseName}/dump/{id}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GetHostingPrivateDatabaseDatabaseDumpRequest",
+  }) as any as 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 const HostingPrivateDatabaseDatabaseDump = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    creationDate: S.optional(S.String),
+    databaseName: S.optional(S.String),
+    deletionDate: S.optional(S.String),
+    id: S.optional(S.Number),
+    url: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "HostingPrivateDatabaseDatabaseDump",
+}) as any as S.Schema<HostingPrivateDatabaseDatabaseDump>;
+
+export interface GetHostingPrivateDatabaseDatabaseExtensionRequest {
+  /** Service name */
+  serviceName: string;
+  /** Database name */
+  databaseName: string;
+  /** Extension name */
+  extensionName: string;
+}
+export const GetHostingPrivateDatabaseDatabaseExtensionRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      databaseName: S.String.pipe(T.Label()),
+      extensionName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/database/{databaseName}/extension/{extensionName}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GetHostingPrivateDatabaseDatabaseExtensionRequest",
+  }) as any as S.Schema<GetHostingPrivateDatabaseDatabaseExtensionRequest>;
+
+/** Required extensions */
+export type HostingPrivateDatabaseExtensionRequiredExtensionsList =
+  Array<string>;
+export const HostingPrivateDatabaseExtensionRequiredExtensionsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<HostingPrivateDatabaseExtensionRequiredExtensionsList>;
+
+/** Extension status */
+export type HostingPrivateDatabaseExtensionStatusEnum =
+  | "disabled"
+  | "disabling"
+  | "enabled"
+  | "enabling";
+export const HostingPrivateDatabaseExtensionStatusEnum = /*@__PURE__*/ S.String;
+
+/** Webcloud Database extension */
+export interface HostingPrivateDatabaseExtension {
+  /** Extension details */
+  description?: string;
+  /** Extension name */
+  extensionName?: string;
+  /** Required extensions */
+  requiredExtensions?: HostingPrivateDatabaseExtensionRequiredExtensionsList;
+  /** Extension status */
+  status?: HostingPrivateDatabaseExtensionStatusEnum;
+}
+export const HostingPrivateDatabaseExtension = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    description: S.optional(S.String),
+    extensionName: S.optional(S.String),
+    requiredExtensions: S.optional(
+      HostingPrivateDatabaseExtensionRequiredExtensionsList,
+    ),
+    status: S.optional(HostingPrivateDatabaseExtensionStatusEnum),
+  }),
+).annotate({
+  identifier: "HostingPrivateDatabaseExtension",
+}) as any as S.Schema<HostingPrivateDatabaseExtension>;
+
+export interface GetHostingPrivateDatabaseDumpRequest {
+  /** Service name */
+  serviceName: string;
+  /** Dump ID */
+  dumpId: number;
+}
+export const GetHostingPrivateDatabaseDumpRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      dumpId: S.Number.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/dump/{dumpId}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetHostingPrivateDatabaseDumpRequest",
+}) as any as 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 const HostingPrivateDatabaseDump = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    creationDate: S.optional(S.String),
+    databaseName: S.optional(S.String),
+    deletionDate: S.optional(S.String),
+    dumpId: S.optional(S.Number),
+    orphan: S.optional(S.Boolean),
+    url: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "HostingPrivateDatabaseDump",
+}) as any as S.Schema<HostingPrivateDatabaseDump>;
+
+export interface GetHostingPrivateDatabaseLogKindRequest {
+  /** Service name */
+  serviceName: string;
+  /** Name */
+  name: string;
+}
+export const GetHostingPrivateDatabaseLogKindRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      name: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/log/kind/{name}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetHostingPrivateDatabaseLogKindRequest",
+}) as any as S.Schema<GetHostingPrivateDatabaseLogKindRequest>;
+
+/** List of additional log fields managed in this log kind */
+export type DbaasLogsLogKindAdditionalReturnedFieldsList = Array<string>;
+export const DbaasLogsLogKindAdditionalReturnedFieldsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as 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 const DbaasLogsLogKind = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    additionalReturnedFields: S.optional(
+      DbaasLogsLogKindAdditionalReturnedFieldsList,
+    ),
+    createdAt: S.optional(S.String),
+    displayName: S.optional(S.String),
+    kindId: S.optional(S.String),
+    name: S.optional(S.String),
+    updatedAt: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "DbaasLogsLogKind",
+}) as any as S.Schema<DbaasLogsLogKind>;
+
+export interface GetHostingPrivateDatabaseLogSubscriptionRequest {
+  /** Service name */
+  serviceName: string;
+  /** Subscription ID */
+  subscriptionId: string;
+}
+export const GetHostingPrivateDatabaseLogSubscriptionRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      subscriptionId: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/log/subscription/{subscriptionId}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GetHostingPrivateDatabaseLogSubscriptionRequest",
+  }) as any as S.Schema<GetHostingPrivateDatabaseLogSubscriptionRequest>;
+
+/** Log subscription resource */
+export interface DbaasLogsLogSubscriptionResource {
+  /** Name of subscribed resource */
+  name?: string;
+  /** Type of subscribed resource */
+  type?: string;
+}
+export const DbaasLogsLogSubscriptionResource = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.optional(S.String),
+    type: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "DbaasLogsLogSubscriptionResource",
+}) as any as 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 const DbaasLogsLogSubscription = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    createdAt: S.optional(S.String),
+    kind: S.optional(S.String),
+    resource: S.optional(DbaasLogsLogSubscriptionResource),
+    serviceName: S.optional(S.String),
+    streamId: S.optional(S.String),
+    subscriptionId: S.optional(S.String),
+    updatedAt: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "DbaasLogsLogSubscription",
+}) as any as S.Schema<DbaasLogsLogSubscription>;
+
+export interface GetHostingPrivateDatabaseMetricsTokenRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const GetHostingPrivateDatabaseMetricsTokenRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/metricsToken",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GetHostingPrivateDatabaseMetricsTokenRequest",
+  }) as any as S.Schema<GetHostingPrivateDatabaseMetricsTokenRequest>;
+
+/** Metrics token */
+export interface HostingPrivateDatabaseMetricsToken {
+  /** Backend url */
+  endpoint?: string;
+  /** Generated token */
+  token?: string;
+}
+export const HostingPrivateDatabaseMetricsToken = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    endpoint: S.optional(S.String),
+    token: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "HostingPrivateDatabaseMetricsToken",
+}) as any as S.Schema<HostingPrivateDatabaseMetricsToken>;
+
+export interface GetHostingPrivateDatabaseServiceInfosRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const GetHostingPrivateDatabaseServiceInfosRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/serviceInfos",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GetHostingPrivateDatabaseServiceInfosRequest",
+  }) as any as S.Schema<GetHostingPrivateDatabaseServiceInfosRequest>;
+
+/** All the possible renew period of your service in month */
+export type ServicesServicePossibleRenewPeriodList = Array<number>;
+export const ServicesServicePossibleRenewPeriodList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as 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 const ServiceRenewType = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    automatic: S.optional(S.Boolean),
+    deleteAtExpiration: S.optional(S.Boolean),
+    forced: S.optional(S.Boolean),
+    manualPayment: S.optional(S.NullOr(S.Boolean)),
+    period: S.optional(S.NullOr(S.Number)),
+  }),
+).annotate({
+  identifier: "ServiceRenewType",
+}) as any as S.Schema<ServiceRenewType>;
+
+/** Detailed renewal type of a service */
+export type ServiceRenewalTypeEnum =
+  | "automaticForcedProduct"
+  | "automaticV2012"
+  | "automaticV2014"
+  | "automaticV2016"
+  | "manual"
+  | "oneShot"
+  | "option";
+export const ServiceRenewalTypeEnum = /*@__PURE__*/ S.String;
+
+/** service.StateEnum */
+export type ServiceStateEnum =
+  | "autorenewInProgress"
+  | "expired"
+  | "inCreation"
+  | "ok"
+  | "pendingDebt"
+  | "unPaid";
+export const ServiceStateEnum = /*@__PURE__*/ S.String;
+
+/** 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 const ServicesService = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    canDeleteAtExpiration: S.optional(S.Boolean),
+    contactAdmin: S.optional(S.String),
+    contactBilling: S.optional(S.String),
+    contactTech: S.optional(S.String),
+    creation: S.optional(S.String),
+    domain: S.optional(S.String),
+    engagedUpTo: S.optional(S.NullOr(S.String)),
+    expiration: S.optional(S.String),
+    possibleRenewPeriod: S.optional(
+      S.NullOr(ServicesServicePossibleRenewPeriodList),
+    ),
+    renew: S.optional(S.NullOr(ServiceRenewType)),
+    renewalType: S.optional(ServiceRenewalTypeEnum),
+    serviceId: S.optional(S.Number),
+    status: S.optional(ServiceStateEnum),
+  }),
+).annotate({
+  identifier: "ServicesService",
+}) as any as S.Schema<ServicesService>;
+
+export interface GetHostingPrivateDatabaseTaskRequest {
+  /** Service name */
+  serviceName: string;
+  /** Id */
+  id: number;
+}
+export const GetHostingPrivateDatabaseTaskRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      id: S.Number.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/tasks/{id}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetHostingPrivateDatabaseTaskRequest",
+}) as any as S.Schema<GetHostingPrivateDatabaseTaskRequest>;
+
+export interface GetHostingPrivateDatabaseUserRequest {
+  /** Service name */
+  serviceName: string;
+  /** User name */
+  userName: string;
+}
+export const GetHostingPrivateDatabaseUserRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      userName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/user/{userName}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetHostingPrivateDatabaseUserRequest",
+}) as any as 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 const HostingPrivateDatabaseUserDatabase = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    databaseName: S.optional(S.String),
+    grantId: S.optional(S.Number),
+    grantType: S.optional(HostingPrivateDatabaseGrantGrantEnum),
+  }),
+).annotate({
+  identifier: "HostingPrivateDatabaseUserDatabase",
+}) as any as S.Schema<HostingPrivateDatabaseUserDatabase>;
+
+/** Databases granted for this user */
+export type HostingPrivateDatabaseUserDatabasesList =
+  Array<HostingPrivateDatabaseUserDatabase>;
+export const HostingPrivateDatabaseUserDatabasesList = /*@__PURE__*/ S.Array(
+  HostingPrivateDatabaseUserDatabase,
+) as any as 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 const HostingPrivateDatabaseUser = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    creationDate: S.optional(S.String),
+    databases: S.optional(HostingPrivateDatabaseUserDatabasesList),
+    userName: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "HostingPrivateDatabaseUser",
+}) as any as S.Schema<HostingPrivateDatabaseUser>;
+
+export interface GetHostingPrivateDatabaseUserGrantRequest {
+  /** Service name */
+  serviceName: string;
+  /** User name */
+  userName: string;
+  /** Database name */
+  databaseName: string;
+}
+export const GetHostingPrivateDatabaseUserGrantRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      userName: S.String.pipe(T.Label()),
+      databaseName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/user/{userName}/grant/{databaseName}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GetHostingPrivateDatabaseUserGrantRequest",
+  }) as any as 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 const HostingPrivateDatabaseUserGrant = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    creationDate: S.optional(S.String),
+    databaseName: S.optional(S.String),
+    grant: S.optional(HostingPrivateDatabaseGrantGrantEnum),
+  }),
+).annotate({
+  identifier: "HostingPrivateDatabaseUserGrant",
+}) as any as S.Schema<HostingPrivateDatabaseUserGrant>;
+
+export interface GetHostingPrivateDatabaseWebhostingNetworkRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const GetHostingPrivateDatabaseWebhostingNetworkRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/webhostingNetwork",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GetHostingPrivateDatabaseWebhostingNetworkRequest",
+  }) as any as S.Schema<GetHostingPrivateDatabaseWebhostingNetworkRequest>;
+
+/** Webhosting network status */
+export type HostingPrivateDatabaseWebhostingNetworkStatusEnum =
+  | "disabled"
+  | "disabling"
+  | "enabled"
+  | "enabling";
+export const HostingPrivateDatabaseWebhostingNetworkStatusEnum =
+  /*@__PURE__*/ S.String;
+
+/** webhosting Network */
+export interface HostingPrivateDatabaseWebhostingNetwork {
+  /** Webhosting network status */
+  status?: HostingPrivateDatabaseWebhostingNetworkStatusEnum;
+}
+export const HostingPrivateDatabaseWebhostingNetwork = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      status: S.optional(HostingPrivateDatabaseWebhostingNetworkStatusEnum),
+    }),
+).annotate({
+  identifier: "HostingPrivateDatabaseWebhostingNetwork",
+}) as any as S.Schema<HostingPrivateDatabaseWebhostingNetwork>;
+
+export interface GetHostingPrivateDatabaseWhitelistRequest {
+  /** Service name */
+  serviceName: string;
+  /** Ip */
+  ip: string;
+}
+export const GetHostingPrivateDatabaseWhitelistRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      ip: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/whitelist/{ip}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GetHostingPrivateDatabaseWhitelistRequest",
+  }) as any as S.Schema<GetHostingPrivateDatabaseWhitelistRequest>;
+
+/** Whitelist status */
+export type HostingPrivateDatabaseWhitelistStatusEnum =
+  | "created"
+  | "creating"
+  | "deleting"
+  | "updating";
+export const HostingPrivateDatabaseWhitelistStatusEnum = /*@__PURE__*/ S.String;
+
+/** 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 const HostingPrivateDatabaseWhitelist = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    creationDate: S.optional(S.String),
+    ip: S.optional(S.String),
+    lastUpdate: S.optional(S.String),
+    name: S.optional(S.NullOr(S.String)),
+    service: S.optional(S.Boolean),
+    sftp: S.optional(S.Boolean),
+    status: S.optional(HostingPrivateDatabaseWhitelistStatusEnum),
+    taskId: S.optional(S.NullOr(S.Number)),
+  }),
+).annotate({
+  identifier: "HostingPrivateDatabaseWhitelist",
+}) as any as 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 const ImportHostingPrivateDatabaseDatabaseRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      databaseName: S.String.pipe(T.Label()),
+      documentId: S.String,
+      flushDatabase: S.optional(S.Boolean),
+      sendEmail: S.optional(S.Boolean),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/database/{databaseName}/import",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ImportHostingPrivateDatabaseDatabaseRequest",
+  }) as any as S.Schema<ImportHostingPrivateDatabaseDatabaseRequest>;
+
+/** Resource tag filter */
+export interface IamResourceTagFilterInput {}
+export const IamResourceTagFilterInput = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "IamResourceTagFilterInput",
+}) as any as S.Schema<IamResourceTagFilterInput>;
+
+export type ListHostingPrivateDatabaseRequestIamTagsValueList =
+  Array<IamResourceTagFilterInput>;
+export const ListHostingPrivateDatabaseRequestIamTagsValueList =
+  /*@__PURE__*/ S.Array(
+    IamResourceTagFilterInput,
+  ) as any as S.Schema<ListHostingPrivateDatabaseRequestIamTagsValueList>;
+
+export type ListHostingPrivateDatabaseRequestIamTagsMap = {
+  [key: string]: ListHostingPrivateDatabaseRequestIamTagsValueList | undefined;
+};
+export const ListHostingPrivateDatabaseRequestIamTagsMap =
+  /*@__PURE__*/ S.Record(
+    S.String,
+    ListHostingPrivateDatabaseRequestIamTagsValueList,
+  ) as any as S.Schema<ListHostingPrivateDatabaseRequestIamTagsMap>;
+
+export interface ListHostingPrivateDatabaseRequest {
+  /** Filter resources on IAM tags */
+  iamTags?: ListHostingPrivateDatabaseRequestIamTagsMap;
+}
+export const ListHostingPrivateDatabaseRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    iamTags: S.optional(
+      ListHostingPrivateDatabaseRequestIamTagsMap.pipe(T.Query()),
+    ),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/hosting/privateDatabase", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListHostingPrivateDatabaseRequest",
+}) as any as S.Schema<ListHostingPrivateDatabaseRequest>;
+
+export type ListHostingPrivateDatabaseResponseBodyList = Array<string>;
+export const ListHostingPrivateDatabaseResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListHostingPrivateDatabaseResponseBodyList>;
+
+export type ListHostingPrivateDatabaseResponse =
+  ListHostingPrivateDatabaseResponseBodyList;
+export const ListHostingPrivateDatabaseResponse = /*@__PURE__*/ S.suspend(() =>
+  ListHostingPrivateDatabaseResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListHostingPrivateDatabaseResponse",
+}) as any as S.Schema<ListHostingPrivateDatabaseResponse>;
+
+export interface ListHostingPrivateDatabaseAvailableOrderCapacitiesRequest {
+  offer: HostingPrivateDatabaseOfferEnum | (string & {});
+}
+export const ListHostingPrivateDatabaseAvailableOrderCapacitiesRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      offer: HostingPrivateDatabaseOfferEnum.pipe(T.Query()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/availableOrderCapacities",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListHostingPrivateDatabaseAvailableOrderCapacitiesRequest",
+  }) as any as S.Schema<ListHostingPrivateDatabaseAvailableOrderCapacitiesRequest>;
+
+/** A list of datacenter available for this offer */
+export type HostingPrivateDatabaseAvailableOrderCapacitiesDatacenterList =
+  Array<HostingPrivateDatabaseDatacenterEnum>;
+export const HostingPrivateDatabaseAvailableOrderCapacitiesDatacenterList =
+  /*@__PURE__*/ S.Array(
+    HostingPrivateDatabaseDatacenterEnum,
+  ) as any as S.Schema<HostingPrivateDatabaseAvailableOrderCapacitiesDatacenterList>;
+
+/** Private database available ram sizes */
+export type HostingPrivateDatabaseAvailableRamSizeEnum =
+  | "1024"
+  | "2048"
+  | "4096"
+  | "512";
+export const HostingPrivateDatabaseAvailableRamSizeEnum =
+  /*@__PURE__*/ S.String;
+
+/** A list of ram size available for this offer */
+export type HostingPrivateDatabaseAvailableOrderCapacitiesRamList =
+  Array<HostingPrivateDatabaseAvailableRamSizeEnum>;
+export const HostingPrivateDatabaseAvailableOrderCapacitiesRamList =
+  /*@__PURE__*/ S.Array(
+    HostingPrivateDatabaseAvailableRamSizeEnum,
+  ) as any as S.Schema<HostingPrivateDatabaseAvailableOrderCapacitiesRamList>;
+
+/** A list of version available for this offer */
+export type HostingPrivateDatabaseAvailableOrderCapacitiesVersionList =
+  Array<HostingPrivateDatabaseAvailableVersionEnum>;
+export const HostingPrivateDatabaseAvailableOrderCapacitiesVersionList =
+  /*@__PURE__*/ S.Array(
+    HostingPrivateDatabaseAvailableVersionEnum,
+  ) as any as 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 const HostingPrivateDatabaseAvailableOrderCapacities =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      datacenter: S.optional(
+        HostingPrivateDatabaseAvailableOrderCapacitiesDatacenterList,
+      ),
+      offer: S.optional(HostingPrivateDatabaseOfferEnum),
+      ram: S.optional(HostingPrivateDatabaseAvailableOrderCapacitiesRamList),
+      version: S.optional(
+        HostingPrivateDatabaseAvailableOrderCapacitiesVersionList,
+      ),
+    }),
+  ).annotate({
+    identifier: "HostingPrivateDatabaseAvailableOrderCapacities",
+  }) as any as S.Schema<HostingPrivateDatabaseAvailableOrderCapacities>;
+
+export interface ListHostingPrivateDatabaseAvailableVersionsRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const ListHostingPrivateDatabaseAvailableVersionsRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/availableVersions",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListHostingPrivateDatabaseAvailableVersionsRequest",
+  }) as any as S.Schema<ListHostingPrivateDatabaseAvailableVersionsRequest>;
+
+export type ListHostingPrivateDatabaseAvailableVersionsResponseBodyList =
+  Array<HostingPrivateDatabaseAvailableVersionEnum>;
+export const ListHostingPrivateDatabaseAvailableVersionsResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    HostingPrivateDatabaseAvailableVersionEnum,
+  ) as any as S.Schema<ListHostingPrivateDatabaseAvailableVersionsResponseBodyList>;
+
+export type ListHostingPrivateDatabaseAvailableVersionsResponse =
+  ListHostingPrivateDatabaseAvailableVersionsResponseBodyList;
+export const ListHostingPrivateDatabaseAvailableVersionsResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListHostingPrivateDatabaseAvailableVersionsResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListHostingPrivateDatabaseAvailableVersionsResponse",
+  }) as any as S.Schema<ListHostingPrivateDatabaseAvailableVersionsResponse>;
+
+export interface ListHostingPrivateDatabaseConfigRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const ListHostingPrivateDatabaseConfigRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/config",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListHostingPrivateDatabaseConfigRequest",
+}) as any as S.Schema<ListHostingPrivateDatabaseConfigRequest>;
+
+/** Configuration available values */
+export type HostingPrivateDatabaseConfigDetailAvailableValuesList =
+  Array<string>;
+export const HostingPrivateDatabaseConfigDetailAvailableValuesList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<HostingPrivateDatabaseConfigDetailAvailableValuesList>;
+
+/** Web Cloud Database config type */
+export type HostingPrivateDatabaseConfigTypeEnum =
+  | "boolean"
+  | "number"
+  | "string";
+export const HostingPrivateDatabaseConfigTypeEnum = /*@__PURE__*/ S.String;
+
+/** 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 const HostingPrivateDatabaseConfigDetail = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    availableValues: S.optional(
+      HostingPrivateDatabaseConfigDetailAvailableValuesList,
+    ),
+    defaultValue: S.optional(S.String),
+    description: S.optional(S.String),
+    key: S.optional(S.String),
+    lastUpdate: S.optional(S.String),
+    type: S.optional(HostingPrivateDatabaseConfigTypeEnum),
+    unit: S.optional(S.NullOr(S.String)),
+    value: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "HostingPrivateDatabaseConfigDetail",
+}) as any as S.Schema<HostingPrivateDatabaseConfigDetail>;
+
+/** Configuration details */
+export type HostingPrivateDatabaseConfigsDetailsList =
+  Array<HostingPrivateDatabaseConfigDetail>;
+export const HostingPrivateDatabaseConfigsDetailsList = /*@__PURE__*/ S.Array(
+  HostingPrivateDatabaseConfigDetail,
+) as any as S.Schema<HostingPrivateDatabaseConfigsDetailsList>;
+
+/** Web Cloud Database config status */
+export type HostingPrivateDatabaseConfigStatusEnum = "applied" | "updating";
+export const HostingPrivateDatabaseConfigStatusEnum = /*@__PURE__*/ S.String;
+
+/** 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 const HostingPrivateDatabaseConfigs = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    details: S.optional(HostingPrivateDatabaseConfigsDetailsList),
+    lastUpdate: S.optional(S.String),
+    status: S.optional(HostingPrivateDatabaseConfigStatusEnum),
+    taskId: S.optional(S.NullOr(S.Number)),
+  }),
+).annotate({
+  identifier: "HostingPrivateDatabaseConfigs",
+}) as any as S.Schema<HostingPrivateDatabaseConfigs>;
+
+export interface ListHostingPrivateDatabaseCpuThrottleRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const ListHostingPrivateDatabaseCpuThrottleRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/cpuThrottle",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListHostingPrivateDatabaseCpuThrottleRequest",
+  }) as any as 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 const HostingPrivateDatabaseCpuThrottle = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    endDate: S.optional(S.NullOr(S.String)),
+    startDate: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "HostingPrivateDatabaseCpuThrottle",
+}) as any as S.Schema<HostingPrivateDatabaseCpuThrottle>;
+
+export type ListHostingPrivateDatabaseCpuThrottleResponseBodyList =
+  Array<HostingPrivateDatabaseCpuThrottle>;
+export const ListHostingPrivateDatabaseCpuThrottleResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    HostingPrivateDatabaseCpuThrottle,
+  ) as any as S.Schema<ListHostingPrivateDatabaseCpuThrottleResponseBodyList>;
+
+export type ListHostingPrivateDatabaseCpuThrottleResponse =
+  ListHostingPrivateDatabaseCpuThrottleResponseBodyList;
+export const ListHostingPrivateDatabaseCpuThrottleResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListHostingPrivateDatabaseCpuThrottleResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListHostingPrivateDatabaseCpuThrottleResponse",
+  }) as any as S.Schema<ListHostingPrivateDatabaseCpuThrottleResponse>;
+
+export interface ListHostingPrivateDatabaseDatabaseRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const ListHostingPrivateDatabaseDatabaseRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/database",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListHostingPrivateDatabaseDatabaseRequest",
+  }) as any as S.Schema<ListHostingPrivateDatabaseDatabaseRequest>;
+
+export type ListHostingPrivateDatabaseDatabaseResponseBodyList = Array<string>;
+export const ListHostingPrivateDatabaseDatabaseResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListHostingPrivateDatabaseDatabaseResponseBodyList>;
+
+export type ListHostingPrivateDatabaseDatabaseResponse =
+  ListHostingPrivateDatabaseDatabaseResponseBodyList;
+export const ListHostingPrivateDatabaseDatabaseResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListHostingPrivateDatabaseDatabaseResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListHostingPrivateDatabaseDatabaseResponse",
+  }) as any as S.Schema<ListHostingPrivateDatabaseDatabaseResponse>;
+
+export interface ListHostingPrivateDatabaseDatabaseCopyRequest {
+  /** Service name */
+  serviceName: string;
+  /** Database name */
+  databaseName: string;
+}
+export const ListHostingPrivateDatabaseDatabaseCopyRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      databaseName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/database/{databaseName}/copy",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListHostingPrivateDatabaseDatabaseCopyRequest",
+  }) as any as S.Schema<ListHostingPrivateDatabaseDatabaseCopyRequest>;
+
+export type ListHostingPrivateDatabaseDatabaseCopyResponseBodyList =
+  Array<string>;
+export const ListHostingPrivateDatabaseDatabaseCopyResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListHostingPrivateDatabaseDatabaseCopyResponseBodyList>;
+
+export type ListHostingPrivateDatabaseDatabaseCopyResponse =
+  ListHostingPrivateDatabaseDatabaseCopyResponseBodyList;
+export const ListHostingPrivateDatabaseDatabaseCopyResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListHostingPrivateDatabaseDatabaseCopyResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListHostingPrivateDatabaseDatabaseCopyResponse",
+  }) as any as S.Schema<ListHostingPrivateDatabaseDatabaseCopyResponse>;
+
+export interface ListHostingPrivateDatabaseDatabaseDumpRequest {
+  /** Service name */
+  serviceName: string;
+  /** Database name */
+  databaseName: string;
+}
+export const ListHostingPrivateDatabaseDatabaseDumpRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      databaseName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/database/{databaseName}/dump",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListHostingPrivateDatabaseDatabaseDumpRequest",
+  }) as any as S.Schema<ListHostingPrivateDatabaseDatabaseDumpRequest>;
+
+export type ListHostingPrivateDatabaseDatabaseDumpResponseBodyList =
+  Array<number>;
+export const ListHostingPrivateDatabaseDatabaseDumpResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.Number,
+  ) as any as S.Schema<ListHostingPrivateDatabaseDatabaseDumpResponseBodyList>;
+
+export type ListHostingPrivateDatabaseDatabaseDumpResponse =
+  ListHostingPrivateDatabaseDatabaseDumpResponseBodyList;
+export const ListHostingPrivateDatabaseDatabaseDumpResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListHostingPrivateDatabaseDatabaseDumpResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListHostingPrivateDatabaseDatabaseDumpResponse",
+  }) as any as 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 const ListHostingPrivateDatabaseDatabaseExtensionRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      databaseName: S.String.pipe(T.Label()),
+      extensionName: S.optional(S.String.pipe(T.Query())),
+      status: S.optional(
+        HostingPrivateDatabaseExtensionStatusEnum.pipe(T.Query()),
+      ),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/database/{databaseName}/extension",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListHostingPrivateDatabaseDatabaseExtensionRequest",
+  }) as any as S.Schema<ListHostingPrivateDatabaseDatabaseExtensionRequest>;
+
+export type ListHostingPrivateDatabaseDatabaseExtensionResponseBodyList =
+  Array<string>;
+export const ListHostingPrivateDatabaseDatabaseExtensionResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListHostingPrivateDatabaseDatabaseExtensionResponseBodyList>;
+
+export type ListHostingPrivateDatabaseDatabaseExtensionResponse =
+  ListHostingPrivateDatabaseDatabaseExtensionResponseBodyList;
+export const ListHostingPrivateDatabaseDatabaseExtensionResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListHostingPrivateDatabaseDatabaseExtensionResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListHostingPrivateDatabaseDatabaseExtensionResponse",
+  }) as any as 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 const ListHostingPrivateDatabaseDumpRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      databaseName: S.optional(S.String.pipe(T.Query())),
+      orphan: S.optional(S.Boolean.pipe(T.Query())),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/dump",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListHostingPrivateDatabaseDumpRequest",
+}) as any as S.Schema<ListHostingPrivateDatabaseDumpRequest>;
+
+export type ListHostingPrivateDatabaseDumpResponseBodyList = Array<number>;
+export const ListHostingPrivateDatabaseDumpResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.Number,
+  ) as any as S.Schema<ListHostingPrivateDatabaseDumpResponseBodyList>;
+
+export type ListHostingPrivateDatabaseDumpResponse =
+  ListHostingPrivateDatabaseDumpResponseBodyList;
+export const ListHostingPrivateDatabaseDumpResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    ListHostingPrivateDatabaseDumpResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListHostingPrivateDatabaseDumpResponse",
+}) as any as S.Schema<ListHostingPrivateDatabaseDumpResponse>;
+
+export interface ListHostingPrivateDatabaseLogKindRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const ListHostingPrivateDatabaseLogKindRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/log/kind",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListHostingPrivateDatabaseLogKindRequest",
+}) as any as S.Schema<ListHostingPrivateDatabaseLogKindRequest>;
+
+export type ListHostingPrivateDatabaseLogKindResponseBodyList = Array<string>;
+export const ListHostingPrivateDatabaseLogKindResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListHostingPrivateDatabaseLogKindResponseBodyList>;
+
+export type ListHostingPrivateDatabaseLogKindResponse =
+  ListHostingPrivateDatabaseLogKindResponseBodyList;
+export const ListHostingPrivateDatabaseLogKindResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListHostingPrivateDatabaseLogKindResponseBodyList.pipe(T.RawResponseRoot()),
+  ).annotate({
+    identifier: "ListHostingPrivateDatabaseLogKindResponse",
+  }) as any as S.Schema<ListHostingPrivateDatabaseLogKindResponse>;
+
+export interface ListHostingPrivateDatabaseLogSubscriptionRequest {
+  /** Service name */
+  serviceName: string;
+  /** Filter on a specific kind */
+  kind?: string;
+}
+export const ListHostingPrivateDatabaseLogSubscriptionRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      kind: S.optional(S.String.pipe(T.Query())),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/log/subscription",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListHostingPrivateDatabaseLogSubscriptionRequest",
+  }) as any as S.Schema<ListHostingPrivateDatabaseLogSubscriptionRequest>;
+
+export type ListHostingPrivateDatabaseLogSubscriptionResponseBodyList =
+  Array<string>;
+export const ListHostingPrivateDatabaseLogSubscriptionResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListHostingPrivateDatabaseLogSubscriptionResponseBodyList>;
+
+export type ListHostingPrivateDatabaseLogSubscriptionResponse =
+  ListHostingPrivateDatabaseLogSubscriptionResponseBodyList;
+export const ListHostingPrivateDatabaseLogSubscriptionResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListHostingPrivateDatabaseLogSubscriptionResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListHostingPrivateDatabaseLogSubscriptionResponse",
+  }) as any as S.Schema<ListHostingPrivateDatabaseLogSubscriptionResponse>;
+
+export interface ListHostingPrivateDatabaseOomRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const ListHostingPrivateDatabaseOomRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/oom",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListHostingPrivateDatabaseOomRequest",
+}) as any as S.Schema<ListHostingPrivateDatabaseOomRequest>;
+
+/** List of privatesql OOM kill */
+export interface HostingPrivateDatabaseOom {
+  /** Date of the OOM kill */
+  date?: string;
+  /** Memory size reached */
+  sizeReached?: number;
+}
+export const HostingPrivateDatabaseOom = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    date: S.optional(S.String),
+    sizeReached: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "HostingPrivateDatabaseOom",
+}) as any as S.Schema<HostingPrivateDatabaseOom>;
+
+export type ListHostingPrivateDatabaseOomResponseBodyList =
+  Array<HostingPrivateDatabaseOom>;
+export const ListHostingPrivateDatabaseOomResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    HostingPrivateDatabaseOom,
+  ) as any as S.Schema<ListHostingPrivateDatabaseOomResponseBodyList>;
+
+export type ListHostingPrivateDatabaseOomResponse =
+  ListHostingPrivateDatabaseOomResponseBodyList;
+export const ListHostingPrivateDatabaseOomResponse = /*@__PURE__*/ S.suspend(
+  () => ListHostingPrivateDatabaseOomResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListHostingPrivateDatabaseOomResponse",
+}) as any as 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 const ListHostingPrivateDatabaseTasksRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      function: S.optional(
+        HostingPrivateDatabaseTaskFunctionEnum.pipe(T.Query()),
+      ),
+      status: S.optional(HostingPrivateDatabaseTaskStatusEnum.pipe(T.Query())),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/tasks",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListHostingPrivateDatabaseTasksRequest",
+}) as any as S.Schema<ListHostingPrivateDatabaseTasksRequest>;
+
+export type ListHostingPrivateDatabaseTasksResponseBodyList = Array<number>;
+export const ListHostingPrivateDatabaseTasksResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.Number,
+  ) as any as S.Schema<ListHostingPrivateDatabaseTasksResponseBodyList>;
+
+export type ListHostingPrivateDatabaseTasksResponse =
+  ListHostingPrivateDatabaseTasksResponseBodyList;
+export const ListHostingPrivateDatabaseTasksResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    ListHostingPrivateDatabaseTasksResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListHostingPrivateDatabaseTasksResponse",
+}) as any as S.Schema<ListHostingPrivateDatabaseTasksResponse>;
+
+export interface ListHostingPrivateDatabaseUserRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const ListHostingPrivateDatabaseUserRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/user",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListHostingPrivateDatabaseUserRequest",
+}) as any as S.Schema<ListHostingPrivateDatabaseUserRequest>;
+
+export type ListHostingPrivateDatabaseUserResponseBodyList = Array<string>;
+export const ListHostingPrivateDatabaseUserResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListHostingPrivateDatabaseUserResponseBodyList>;
+
+export type ListHostingPrivateDatabaseUserResponse =
+  ListHostingPrivateDatabaseUserResponseBodyList;
+export const ListHostingPrivateDatabaseUserResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    ListHostingPrivateDatabaseUserResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListHostingPrivateDatabaseUserResponse",
+}) as any as S.Schema<ListHostingPrivateDatabaseUserResponse>;
+
+export interface ListHostingPrivateDatabaseUserGrantRequest {
+  /** Service name */
+  serviceName: string;
+  /** User name */
+  userName: string;
+}
+export const ListHostingPrivateDatabaseUserGrantRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      userName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/user/{userName}/grant",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListHostingPrivateDatabaseUserGrantRequest",
+  }) as any as S.Schema<ListHostingPrivateDatabaseUserGrantRequest>;
+
+export type ListHostingPrivateDatabaseUserGrantResponseBodyList = Array<string>;
+export const ListHostingPrivateDatabaseUserGrantResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListHostingPrivateDatabaseUserGrantResponseBodyList>;
+
+export type ListHostingPrivateDatabaseUserGrantResponse =
+  ListHostingPrivateDatabaseUserGrantResponseBodyList;
+export const ListHostingPrivateDatabaseUserGrantResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListHostingPrivateDatabaseUserGrantResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListHostingPrivateDatabaseUserGrantResponse",
+  }) as any as S.Schema<ListHostingPrivateDatabaseUserGrantResponse>;
+
+export interface ListHostingPrivateDatabaseWebsRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const ListHostingPrivateDatabaseWebsRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/webs",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListHostingPrivateDatabaseWebsRequest",
+}) as any as S.Schema<ListHostingPrivateDatabaseWebsRequest>;
+
+export type ListHostingPrivateDatabaseWebsResponseBodyList = Array<string>;
+export const ListHostingPrivateDatabaseWebsResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListHostingPrivateDatabaseWebsResponseBodyList>;
+
+export type ListHostingPrivateDatabaseWebsResponse =
+  ListHostingPrivateDatabaseWebsResponseBodyList;
+export const ListHostingPrivateDatabaseWebsResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    ListHostingPrivateDatabaseWebsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListHostingPrivateDatabaseWebsResponse",
+}) as any as 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 const ListHostingPrivateDatabaseWhitelistRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      ip: S.optional(S.String.pipe(T.Query())),
+      service: S.optional(S.Boolean.pipe(T.Query())),
+      sftp: S.optional(S.Boolean.pipe(T.Query())),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/hosting/privateDatabase/{serviceName}/whitelist",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListHostingPrivateDatabaseWhitelistRequest",
+  }) as any as S.Schema<ListHostingPrivateDatabaseWhitelistRequest>;
+
+export type ListHostingPrivateDatabaseWhitelistResponseBodyList = Array<string>;
+export const ListHostingPrivateDatabaseWhitelistResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListHostingPrivateDatabaseWhitelistResponseBodyList>;
+
+export type ListHostingPrivateDatabaseWhitelistResponse =
+  ListHostingPrivateDatabaseWhitelistResponseBodyList;
+export const ListHostingPrivateDatabaseWhitelistResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListHostingPrivateDatabaseWhitelistResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListHostingPrivateDatabaseWhitelistResponse",
+  }) as any as 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 const PutHostingPrivateDatabaseRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    displayName: S.optional(S.NullOr(S.String)),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/hosting/privateDatabase/{serviceName}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutHostingPrivateDatabaseRequest",
+}) as any as S.Schema<PutHostingPrivateDatabaseRequest>;
+
+export interface PutHostingPrivateDatabaseResponse {}
+export const PutHostingPrivateDatabaseResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutHostingPrivateDatabaseResponse",
+}) as any as S.Schema<PutHostingPrivateDatabaseResponse>;
+
+export interface PutHostingPrivateDatabaseServiceInfosRequest {
+  /** Service name */
+  serviceName: string;
+  /** Way of handling the renew */
+  renew?: ServiceRenewType | null;
+}
+export const PutHostingPrivateDatabaseServiceInfosRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      renew: S.optional(S.NullOr(ServiceRenewType)),
+    }).pipe(
+      T.Http({
+        method: "PUT",
+        uri: "/hosting/privateDatabase/{serviceName}/serviceInfos",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "PutHostingPrivateDatabaseServiceInfosRequest",
+  }) as any as S.Schema<PutHostingPrivateDatabaseServiceInfosRequest>;
+
+export interface PutHostingPrivateDatabaseServiceInfosResponse {}
+export const PutHostingPrivateDatabaseServiceInfosResponse =
+  /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "PutHostingPrivateDatabaseServiceInfosResponse",
+  }) as any as 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 const PutHostingPrivateDatabaseWhitelistRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      ip: S.String.pipe(T.Label()),
+      name: S.optional(S.NullOr(S.String)),
+      service: S.optional(S.Boolean),
+      sftp: S.optional(S.Boolean),
+    }).pipe(
+      T.Http({
+        method: "PUT",
+        uri: "/hosting/privateDatabase/{serviceName}/whitelist/{ip}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "PutHostingPrivateDatabaseWhitelistRequest",
+  }) as any as S.Schema<PutHostingPrivateDatabaseWhitelistRequest>;
+
+export interface PutHostingPrivateDatabaseWhitelistResponse {}
+export const PutHostingPrivateDatabaseWhitelistResponse =
+  /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "PutHostingPrivateDatabaseWhitelistResponse",
+  }) as any as S.Schema<PutHostingPrivateDatabaseWhitelistResponse>;
+
+export interface RestartHostingPrivateDatabaseRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const RestartHostingPrivateDatabaseRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/restart",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "RestartHostingPrivateDatabaseRequest",
+}) as any as S.Schema<RestartHostingPrivateDatabaseRequest>;
+
+export interface RestoreHostingPrivateDatabaseDatabaseDumpRequest {
+  /** Service name */
+  serviceName: string;
+  /** Database name */
+  databaseName: string;
+  /** Id */
+  id: number;
+}
+export const RestoreHostingPrivateDatabaseDatabaseDumpRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      databaseName: S.String.pipe(T.Label()),
+      id: S.Number.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/database/{databaseName}/dump/{id}/restore",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "RestoreHostingPrivateDatabaseDatabaseDumpRequest",
+  }) as any as S.Schema<RestoreHostingPrivateDatabaseDatabaseDumpRequest>;
+
+export interface RestoreHostingPrivateDatabaseDumpRequest {
+  /** Service name */
+  serviceName: string;
+  /** Dump ID */
+  dumpId: number;
+  /** Database name */
+  databaseName?: string;
+}
+export const RestoreHostingPrivateDatabaseDumpRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      dumpId: S.Number.pipe(T.Label()),
+      databaseName: S.optional(S.String),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/dump/{dumpId}/restore",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "RestoreHostingPrivateDatabaseDumpRequest",
+}) as any as S.Schema<RestoreHostingPrivateDatabaseDumpRequest>;
+
+export interface TerminateHostingPrivateDatabaseRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const TerminateHostingPrivateDatabaseRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/terminate",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "TerminateHostingPrivateDatabaseRequest",
+}) as any as S.Schema<TerminateHostingPrivateDatabaseRequest>;
+
+export type TerminateHostingPrivateDatabaseResponse = string;
+export const TerminateHostingPrivateDatabaseResponse = /*@__PURE__*/ S.suspend(
+  () => S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "TerminateHostingPrivateDatabaseResponse",
+}) as any as S.Schema<TerminateHostingPrivateDatabaseResponse>;
+
+/** ConfigKeyValue */
+export interface HostingPrivateDatabaseConfigKeyValue {
+  /** Web Cloud Database configuration key */
+  key: string;
+  /** Web Cloud Database configuration value */
+  value: string;
+}
+export const HostingPrivateDatabaseConfigKeyValue = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      key: S.String,
+      value: S.String,
+    }),
+).annotate({
+  identifier: "HostingPrivateDatabaseConfigKeyValue",
+}) as any as S.Schema<HostingPrivateDatabaseConfigKeyValue>;
+
+/** Web Cloud Database configurations */
+export type UpdateHostingPrivateDatabaseConfigRequestParametersList =
+  Array<HostingPrivateDatabaseConfigKeyValue>;
+export const UpdateHostingPrivateDatabaseConfigRequestParametersList =
+  /*@__PURE__*/ S.Array(
+    HostingPrivateDatabaseConfigKeyValue,
+  ) as any as S.Schema<UpdateHostingPrivateDatabaseConfigRequestParametersList>;
+
+export interface UpdateHostingPrivateDatabaseConfigRequest {
+  /** Service name */
+  serviceName: string;
+  /** Web Cloud Database configurations */
+  parameters: UpdateHostingPrivateDatabaseConfigRequestParametersList;
+}
+export const UpdateHostingPrivateDatabaseConfigRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      parameters: UpdateHostingPrivateDatabaseConfigRequestParametersList,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/config/update",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "UpdateHostingPrivateDatabaseConfigRequest",
+  }) as any as 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 const UpdateHostingPrivateDatabaseUserGrantRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      userName: S.String.pipe(T.Label()),
+      databaseName: S.String.pipe(T.Label()),
+      grant: HostingPrivateDatabaseGrantGrantEnum,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/hosting/privateDatabase/{serviceName}/user/{userName}/grant/{databaseName}/update",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "UpdateHostingPrivateDatabaseUserGrantRequest",
+  }) as any as S.Schema<UpdateHostingPrivateDatabaseUserGrantRequest>;
+
+export type ConfirmHostingPrivateDatabaseTerminationError = OvhOpError;
+/** Confirm service termination */
+export const confirmHostingPrivateDatabaseTermination: API.OperationMethod<
+  ConfirmHostingPrivateDatabaseTerminationRequest,
+  ConfirmHostingPrivateDatabaseTerminationResponse,
+  ConfirmHostingPrivateDatabaseTerminationError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ConfirmHostingPrivateDatabaseTerminationRequest,
+  output: ConfirmHostingPrivateDatabaseTerminationResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CopyHostingPrivateDatabaseDatabaseError = OvhOpError;
+/** Create a new database copy in a Web Cloud Database */
+export const copyHostingPrivateDatabaseDatabase: API.OperationMethod<
+  CopyHostingPrivateDatabaseDatabaseRequest,
+  HostingPrivateDatabaseDatabaseCopy,
+  CopyHostingPrivateDatabaseDatabaseError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CopyHostingPrivateDatabaseDatabaseRequest,
+  output: HostingPrivateDatabaseDatabaseCopy,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CopyHostingPrivateDatabaseDatabaseRestoreError = OvhOpError;
+/** Request the copy into a Web Cloud Database */
+export const copyHostingPrivateDatabaseDatabaseRestore: API.OperationMethod<
+  CopyHostingPrivateDatabaseDatabaseRestoreRequest,
+  HostingPrivateDatabaseTask,
+  CopyHostingPrivateDatabaseDatabaseRestoreError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CopyHostingPrivateDatabaseDatabaseRestoreRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateHostingPrivateDatabaseChangeContactError = OvhOpError;
+/** Launch a contact change procedure */
+export const createHostingPrivateDatabaseChangeContact: API.OperationMethod<
+  CreateHostingPrivateDatabaseChangeContactRequest,
+  CreateHostingPrivateDatabaseChangeContactResponse,
+  CreateHostingPrivateDatabaseChangeContactError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateHostingPrivateDatabaseChangeContactRequest,
+  output: CreateHostingPrivateDatabaseChangeContactResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateHostingPrivateDatabaseChangeFtpPasswordError = OvhOpError;
+/** Change FTP password of your Web Cloud Database */
+export const createHostingPrivateDatabaseChangeFtpPassword: API.OperationMethod<
+  CreateHostingPrivateDatabaseChangeFtpPasswordRequest,
+  HostingPrivateDatabaseTask,
+  CreateHostingPrivateDatabaseChangeFtpPasswordError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateHostingPrivateDatabaseChangeFtpPasswordRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateHostingPrivateDatabaseChangeVersionError = OvhOpError;
+/** Change DBMS version of your Web Cloud Database */
+export const createHostingPrivateDatabaseChangeVersion: API.OperationMethod<
+  CreateHostingPrivateDatabaseChangeVersionRequest,
+  HostingPrivateDatabaseTask,
+  CreateHostingPrivateDatabaseChangeVersionError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateHostingPrivateDatabaseChangeVersionRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateHostingPrivateDatabaseDatabaseError = OvhOpError;
+/** Create a new database in a Web Cloud Database */
+export const createHostingPrivateDatabaseDatabase: API.OperationMethod<
+  CreateHostingPrivateDatabaseDatabaseRequest,
+  HostingPrivateDatabaseTask,
+  CreateHostingPrivateDatabaseDatabaseError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateHostingPrivateDatabaseDatabaseRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateHostingPrivateDatabaseDatabaseDumpError = OvhOpError;
+/** Request the dump of this database (an email will be sent with a link available 30 days) */
+export const createHostingPrivateDatabaseDatabaseDump: API.OperationMethod<
+  CreateHostingPrivateDatabaseDatabaseDumpRequest,
+  HostingPrivateDatabaseTask,
+  CreateHostingPrivateDatabaseDatabaseDumpError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateHostingPrivateDatabaseDatabaseDumpRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateHostingPrivateDatabaseDatabaseWizardError = OvhOpError;
+/** Create a new database/user and grant it */
+export const createHostingPrivateDatabaseDatabaseWizard: API.OperationMethod<
+  CreateHostingPrivateDatabaseDatabaseWizardRequest,
+  HostingPrivateDatabaseTask,
+  CreateHostingPrivateDatabaseDatabaseWizardError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateHostingPrivateDatabaseDatabaseWizardRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateHostingPrivateDatabaseLogSubscriptionError = OvhOpError;
+/** Create subscription to log to customer for a Web Cloud Database */
+export const createHostingPrivateDatabaseLogSubscription: API.OperationMethod<
+  CreateHostingPrivateDatabaseLogSubscriptionRequest,
+  DbaasLogsLogSubscriptionResponse,
+  CreateHostingPrivateDatabaseLogSubscriptionError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateHostingPrivateDatabaseLogSubscriptionRequest,
+  output: DbaasLogsLogSubscriptionResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateHostingPrivateDatabaseLogUrlError = OvhOpError;
+/** Generate a temporary URL to retrieve logs */
+export const createHostingPrivateDatabaseLogUrl: API.OperationMethod<
+  CreateHostingPrivateDatabaseLogUrlRequest,
+  DbaasLogsTemporaryLogsLink,
+  CreateHostingPrivateDatabaseLogUrlError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateHostingPrivateDatabaseLogUrlRequest,
+  output: DbaasLogsTemporaryLogsLink,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateHostingPrivateDatabaseQuotaRefreshError = OvhOpError;
+/** Refresh the quota of your Web Cloud Database */
+export const createHostingPrivateDatabaseQuotaRefresh: API.OperationMethod<
+  CreateHostingPrivateDatabaseQuotaRefreshRequest,
+  HostingPrivateDatabaseTask,
+  CreateHostingPrivateDatabaseQuotaRefreshError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateHostingPrivateDatabaseQuotaRefreshRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateHostingPrivateDatabaseUserError = OvhOpError;
+/** Create a user on a Web Cloud Database */
+export const createHostingPrivateDatabaseUser: API.OperationMethod<
+  CreateHostingPrivateDatabaseUserRequest,
+  HostingPrivateDatabaseTask,
+  CreateHostingPrivateDatabaseUserError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateHostingPrivateDatabaseUserRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateHostingPrivateDatabaseUserChangePasswordError = OvhOpError;
+/** Change the password of a user on a Web Cloud Database */
+export const createHostingPrivateDatabaseUserChangePassword: API.OperationMethod<
+  CreateHostingPrivateDatabaseUserChangePasswordRequest,
+  HostingPrivateDatabaseTask,
+  CreateHostingPrivateDatabaseUserChangePasswordError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateHostingPrivateDatabaseUserChangePasswordRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateHostingPrivateDatabaseUserGrantError = OvhOpError;
+/** Add grant on a Web Cloud Database */
+export const createHostingPrivateDatabaseUserGrant: API.OperationMethod<
+  CreateHostingPrivateDatabaseUserGrantRequest,
+  HostingPrivateDatabaseTask,
+  CreateHostingPrivateDatabaseUserGrantError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateHostingPrivateDatabaseUserGrantRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateHostingPrivateDatabaseWebhostingNetworkError = OvhOpError;
+/** Permit access from the web hosting network on a Web Cloud Database */
+export const createHostingPrivateDatabaseWebhostingNetwork: API.OperationMethod<
+  CreateHostingPrivateDatabaseWebhostingNetworkRequest,
+  HostingPrivateDatabaseTask,
+  CreateHostingPrivateDatabaseWebhostingNetworkError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateHostingPrivateDatabaseWebhostingNetworkRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateHostingPrivateDatabaseWhitelistError = OvhOpError;
+/** Create a new IP whitelist in a Web Cloud Database */
+export const createHostingPrivateDatabaseWhitelist: API.OperationMethod<
+  CreateHostingPrivateDatabaseWhitelistRequest,
+  HostingPrivateDatabaseTask,
+  CreateHostingPrivateDatabaseWhitelistError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateHostingPrivateDatabaseWhitelistRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteHostingPrivateDatabaseDatabaseError = OvhOpError;
+/** Delete a database from a Web Cloud Database */
+export const deleteHostingPrivateDatabaseDatabase: API.OperationMethod<
+  DeleteHostingPrivateDatabaseDatabaseRequest,
+  HostingPrivateDatabaseTask,
+  DeleteHostingPrivateDatabaseDatabaseError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteHostingPrivateDatabaseDatabaseRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteHostingPrivateDatabaseDatabaseCopyError = OvhOpError;
+/** Delete the database copy of a Web Cloud Database */
+export const deleteHostingPrivateDatabaseDatabaseCopy: API.OperationMethod<
+  DeleteHostingPrivateDatabaseDatabaseCopyRequest,
+  DeleteHostingPrivateDatabaseDatabaseCopyResponse,
+  DeleteHostingPrivateDatabaseDatabaseCopyError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteHostingPrivateDatabaseDatabaseCopyRequest,
+  output: DeleteHostingPrivateDatabaseDatabaseCopyResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteHostingPrivateDatabaseDatabaseDumpError = OvhOpError;
+/** Delete dump before expiration date */
+export const deleteHostingPrivateDatabaseDatabaseDump: API.OperationMethod<
+  DeleteHostingPrivateDatabaseDatabaseDumpRequest,
+  HostingPrivateDatabaseTask,
+  DeleteHostingPrivateDatabaseDatabaseDumpError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteHostingPrivateDatabaseDatabaseDumpRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteHostingPrivateDatabaseDumpError = OvhOpError;
+/** Delete a database dump from a Web Cloud Database */
+export const deleteHostingPrivateDatabaseDump: API.OperationMethod<
+  DeleteHostingPrivateDatabaseDumpRequest,
+  HostingPrivateDatabaseTask,
+  DeleteHostingPrivateDatabaseDumpError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteHostingPrivateDatabaseDumpRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteHostingPrivateDatabaseLogSubscriptionError = OvhOpError;
+/** Delete a subscription */
+export const deleteHostingPrivateDatabaseLogSubscription: API.OperationMethod<
+  DeleteHostingPrivateDatabaseLogSubscriptionRequest,
+  DbaasLogsLogSubscriptionResponse,
+  DeleteHostingPrivateDatabaseLogSubscriptionError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteHostingPrivateDatabaseLogSubscriptionRequest,
+  output: DbaasLogsLogSubscriptionResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteHostingPrivateDatabaseUserError = OvhOpError;
+/** Delete a user on a Web Cloud Database */
+export const deleteHostingPrivateDatabaseUser: API.OperationMethod<
+  DeleteHostingPrivateDatabaseUserRequest,
+  HostingPrivateDatabaseTask,
+  DeleteHostingPrivateDatabaseUserError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteHostingPrivateDatabaseUserRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteHostingPrivateDatabaseUserGrantError = OvhOpError;
+/** Delete a grant from a Web Cloud Database */
+export const deleteHostingPrivateDatabaseUserGrant: API.OperationMethod<
+  DeleteHostingPrivateDatabaseUserGrantRequest,
+  HostingPrivateDatabaseTask,
+  DeleteHostingPrivateDatabaseUserGrantError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteHostingPrivateDatabaseUserGrantRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteHostingPrivateDatabaseWebhostingNetworkError = OvhOpError;
+/** Delete access from the web hosting network on a Web Cloud Database */
+export const deleteHostingPrivateDatabaseWebhostingNetwork: API.OperationMethod<
+  DeleteHostingPrivateDatabaseWebhostingNetworkRequest,
+  HostingPrivateDatabaseTask,
+  DeleteHostingPrivateDatabaseWebhostingNetworkError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteHostingPrivateDatabaseWebhostingNetworkRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteHostingPrivateDatabaseWhitelistError = OvhOpError;
+/** Delete an IP whitelist from a Web Cloud Database */
+export const deleteHostingPrivateDatabaseWhitelist: API.OperationMethod<
+  DeleteHostingPrivateDatabaseWhitelistRequest,
+  HostingPrivateDatabaseTask,
+  DeleteHostingPrivateDatabaseWhitelistError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteHostingPrivateDatabaseWhitelistRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DisableHostingPrivateDatabaseDatabaseExtensionError = OvhOpError;
+/** Disable an extension on a Web Cloud Database */
+export const disableHostingPrivateDatabaseDatabaseExtension: API.OperationMethod<
+  DisableHostingPrivateDatabaseDatabaseExtensionRequest,
+  HostingPrivateDatabaseTask,
+  DisableHostingPrivateDatabaseDatabaseExtensionError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DisableHostingPrivateDatabaseDatabaseExtensionRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EnableHostingPrivateDatabaseDatabaseExtensionError = OvhOpError;
+/** Enable an extension on a Web Cloud Database */
+export const enableHostingPrivateDatabaseDatabaseExtension: API.OperationMethod<
+  EnableHostingPrivateDatabaseDatabaseExtensionRequest,
+  HostingPrivateDatabaseTask,
+  EnableHostingPrivateDatabaseDatabaseExtensionError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EnableHostingPrivateDatabaseDatabaseExtensionRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GenerateHostingPrivateDatabaseTemporaryLogsLinkError = OvhOpError;
+/** Generate a temporary link to access logs for a Web Cloud Database */
+export const generateHostingPrivateDatabaseTemporaryLogsLink: API.OperationMethod<
+  GenerateHostingPrivateDatabaseTemporaryLogsLinkRequest,
+  HostingPrivateDatabaseTemporaryUrlInformations,
+  GenerateHostingPrivateDatabaseTemporaryLogsLinkError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GenerateHostingPrivateDatabaseTemporaryLogsLinkRequest,
+  output: HostingPrivateDatabaseTemporaryUrlInformations,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHostingPrivateDatabaseError = OvhOpError;
+/** Get a Web Cloud Database properties */
+export const getHostingPrivateDatabase: API.OperationMethod<
+  GetHostingPrivateDatabaseRequest,
+  HostingPrivateDatabaseServiceWithIAM,
+  GetHostingPrivateDatabaseError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHostingPrivateDatabaseRequest,
+  output: HostingPrivateDatabaseServiceWithIAM,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHostingPrivateDatabaseDatabaseError = OvhOpError;
+/** Get database properties */
+export const getHostingPrivateDatabaseDatabase: API.OperationMethod<
+  GetHostingPrivateDatabaseDatabaseRequest,
+  HostingPrivateDatabaseDatabase,
+  GetHostingPrivateDatabaseDatabaseError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHostingPrivateDatabaseDatabaseRequest,
+  output: HostingPrivateDatabaseDatabase,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHostingPrivateDatabaseDatabaseCopyError = OvhOpError;
+/** Get database copy properties */
+export const getHostingPrivateDatabaseDatabaseCopy: API.OperationMethod<
+  GetHostingPrivateDatabaseDatabaseCopyRequest,
+  HostingPrivateDatabaseDatabaseCopy,
+  GetHostingPrivateDatabaseDatabaseCopyError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHostingPrivateDatabaseDatabaseCopyRequest,
+  output: HostingPrivateDatabaseDatabaseCopy,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHostingPrivateDatabaseDatabaseDumpError = OvhOpError;
+/** Get a database dump from a Web Cloud Database */
+export const getHostingPrivateDatabaseDatabaseDump: API.OperationMethod<
+  GetHostingPrivateDatabaseDatabaseDumpRequest,
+  HostingPrivateDatabaseDatabaseDump,
+  GetHostingPrivateDatabaseDatabaseDumpError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHostingPrivateDatabaseDatabaseDumpRequest,
+  output: HostingPrivateDatabaseDatabaseDump,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHostingPrivateDatabaseDatabaseExtensionError = OvhOpError;
+/** Get properties of a Webcloud Database extension */
+export const getHostingPrivateDatabaseDatabaseExtension: API.OperationMethod<
+  GetHostingPrivateDatabaseDatabaseExtensionRequest,
+  HostingPrivateDatabaseExtension,
+  GetHostingPrivateDatabaseDatabaseExtensionError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHostingPrivateDatabaseDatabaseExtensionRequest,
+  output: HostingPrivateDatabaseExtension,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHostingPrivateDatabaseDumpError = OvhOpError;
+/** Get a database dump from a Web Cloud Database */
+export const getHostingPrivateDatabaseDump: API.OperationMethod<
+  GetHostingPrivateDatabaseDumpRequest,
+  HostingPrivateDatabaseDump,
+  GetHostingPrivateDatabaseDumpError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHostingPrivateDatabaseDumpRequest,
+  output: HostingPrivateDatabaseDump,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHostingPrivateDatabaseLogKindError = OvhOpError;
+/** Get a log kind */
+export const getHostingPrivateDatabaseLogKind: API.OperationMethod<
+  GetHostingPrivateDatabaseLogKindRequest,
+  DbaasLogsLogKind,
+  GetHostingPrivateDatabaseLogKindError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHostingPrivateDatabaseLogKindRequest,
+  output: DbaasLogsLogKind,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHostingPrivateDatabaseLogSubscriptionError = OvhOpError;
+/** Get subscription details */
+export const getHostingPrivateDatabaseLogSubscription: API.OperationMethod<
+  GetHostingPrivateDatabaseLogSubscriptionRequest,
+  DbaasLogsLogSubscription,
+  GetHostingPrivateDatabaseLogSubscriptionError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHostingPrivateDatabaseLogSubscriptionRequest,
+  output: DbaasLogsLogSubscription,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHostingPrivateDatabaseMetricsTokenError = OvhOpError;
+/** Generate a metrics token */
+export const getHostingPrivateDatabaseMetricsToken: API.OperationMethod<
+  GetHostingPrivateDatabaseMetricsTokenRequest,
+  HostingPrivateDatabaseMetricsToken,
+  GetHostingPrivateDatabaseMetricsTokenError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHostingPrivateDatabaseMetricsTokenRequest,
+  output: HostingPrivateDatabaseMetricsToken,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHostingPrivateDatabaseServiceInfosError = OvhOpError;
+/** Get service information */
+export const getHostingPrivateDatabaseServiceInfos: API.OperationMethod<
+  GetHostingPrivateDatabaseServiceInfosRequest,
+  ServicesService,
+  GetHostingPrivateDatabaseServiceInfosError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHostingPrivateDatabaseServiceInfosRequest,
+  output: ServicesService,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHostingPrivateDatabaseTaskError = OvhOpError;
+/** Get task details */
+export const getHostingPrivateDatabaseTask: API.OperationMethod<
+  GetHostingPrivateDatabaseTaskRequest,
+  HostingPrivateDatabaseTask,
+  GetHostingPrivateDatabaseTaskError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHostingPrivateDatabaseTaskRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHostingPrivateDatabaseUserError = OvhOpError;
+/** Get user properties */
+export const getHostingPrivateDatabaseUser: API.OperationMethod<
+  GetHostingPrivateDatabaseUserRequest,
+  HostingPrivateDatabaseUser,
+  GetHostingPrivateDatabaseUserError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHostingPrivateDatabaseUserRequest,
+  output: HostingPrivateDatabaseUser,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHostingPrivateDatabaseUserGrantError = OvhOpError;
+/** Get information about the grants for a user in a Web Cloud Database */
+export const getHostingPrivateDatabaseUserGrant: API.OperationMethod<
+  GetHostingPrivateDatabaseUserGrantRequest,
+  HostingPrivateDatabaseUserGrant,
+  GetHostingPrivateDatabaseUserGrantError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHostingPrivateDatabaseUserGrantRequest,
+  output: HostingPrivateDatabaseUserGrant,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHostingPrivateDatabaseWebhostingNetworkError = OvhOpError;
+/** Get Webhosting network status */
+export const getHostingPrivateDatabaseWebhostingNetwork: API.OperationMethod<
+  GetHostingPrivateDatabaseWebhostingNetworkRequest,
+  HostingPrivateDatabaseWebhostingNetwork,
+  GetHostingPrivateDatabaseWebhostingNetworkError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHostingPrivateDatabaseWebhostingNetworkRequest,
+  output: HostingPrivateDatabaseWebhostingNetwork,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetHostingPrivateDatabaseWhitelistError = OvhOpError;
+/** Get whitelist properties */
+export const getHostingPrivateDatabaseWhitelist: API.OperationMethod<
+  GetHostingPrivateDatabaseWhitelistRequest,
+  HostingPrivateDatabaseWhitelist,
+  GetHostingPrivateDatabaseWhitelistError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetHostingPrivateDatabaseWhitelistRequest,
+  output: HostingPrivateDatabaseWhitelist,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ImportHostingPrivateDatabaseDatabaseError = OvhOpError;
+/** Import a database into a Web Cloud Database */
+export const importHostingPrivateDatabaseDatabase: API.OperationMethod<
+  ImportHostingPrivateDatabaseDatabaseRequest,
+  HostingPrivateDatabaseTask,
+  ImportHostingPrivateDatabaseDatabaseError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ImportHostingPrivateDatabaseDatabaseRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListHostingPrivateDatabaseError = OvhOpError;
+/** List available Web Cloud Databases */
+export const listHostingPrivateDatabase: API.OperationMethod<
+  ListHostingPrivateDatabaseRequest,
+  ListHostingPrivateDatabaseResponse,
+  ListHostingPrivateDatabaseError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListHostingPrivateDatabaseRequest,
+  output: ListHostingPrivateDatabaseResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListHostingPrivateDatabaseAvailableOrderCapacitiesError =
+  OvhOpError;
+/** Get available order capacities */
+export const listHostingPrivateDatabaseAvailableOrderCapacities: API.OperationMethod<
+  ListHostingPrivateDatabaseAvailableOrderCapacitiesRequest,
+  HostingPrivateDatabaseAvailableOrderCapacities,
+  ListHostingPrivateDatabaseAvailableOrderCapacitiesError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListHostingPrivateDatabaseAvailableOrderCapacitiesRequest,
+  output: HostingPrivateDatabaseAvailableOrderCapacities,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListHostingPrivateDatabaseAvailableVersionsError = OvhOpError;
+/** Get the availables versions for this private database */
+export const listHostingPrivateDatabaseAvailableVersions: API.OperationMethod<
+  ListHostingPrivateDatabaseAvailableVersionsRequest,
+  ListHostingPrivateDatabaseAvailableVersionsResponse,
+  ListHostingPrivateDatabaseAvailableVersionsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListHostingPrivateDatabaseAvailableVersionsRequest,
+  output: ListHostingPrivateDatabaseAvailableVersionsResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListHostingPrivateDatabaseConfigError = OvhOpError;
+/** Get the current configuration for this Web Cloud Database */
+export const listHostingPrivateDatabaseConfig: API.OperationMethod<
+  ListHostingPrivateDatabaseConfigRequest,
+  HostingPrivateDatabaseConfigs,
+  ListHostingPrivateDatabaseConfigError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListHostingPrivateDatabaseConfigRequest,
+  output: HostingPrivateDatabaseConfigs,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListHostingPrivateDatabaseCpuThrottleError = OvhOpError;
+/** List of privatesql CPU throttle */
+export const listHostingPrivateDatabaseCpuThrottle: API.OperationMethod<
+  ListHostingPrivateDatabaseCpuThrottleRequest,
+  ListHostingPrivateDatabaseCpuThrottleResponse,
+  ListHostingPrivateDatabaseCpuThrottleError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListHostingPrivateDatabaseCpuThrottleRequest,
+  output: ListHostingPrivateDatabaseCpuThrottleResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListHostingPrivateDatabaseDatabaseError = OvhOpError;
+/** List databases on a privateDatabase */
+export const listHostingPrivateDatabaseDatabase: API.OperationMethod<
+  ListHostingPrivateDatabaseDatabaseRequest,
+  ListHostingPrivateDatabaseDatabaseResponse,
+  ListHostingPrivateDatabaseDatabaseError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListHostingPrivateDatabaseDatabaseRequest,
+  output: ListHostingPrivateDatabaseDatabaseResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListHostingPrivateDatabaseDatabaseCopyError = OvhOpError;
+/** List database copy of a privateDatabase */
+export const listHostingPrivateDatabaseDatabaseCopy: API.OperationMethod<
+  ListHostingPrivateDatabaseDatabaseCopyRequest,
+  ListHostingPrivateDatabaseDatabaseCopyResponse,
+  ListHostingPrivateDatabaseDatabaseCopyError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListHostingPrivateDatabaseDatabaseCopyRequest,
+  output: ListHostingPrivateDatabaseDatabaseCopyResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListHostingPrivateDatabaseDatabaseDumpError = OvhOpError;
+/** Get all database dump from a Web Cloud Database */
+export const listHostingPrivateDatabaseDatabaseDump: API.OperationMethod<
+  ListHostingPrivateDatabaseDatabaseDumpRequest,
+  ListHostingPrivateDatabaseDatabaseDumpResponse,
+  ListHostingPrivateDatabaseDatabaseDumpError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListHostingPrivateDatabaseDatabaseDumpRequest,
+  output: ListHostingPrivateDatabaseDatabaseDumpResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListHostingPrivateDatabaseDatabaseExtensionError = OvhOpError;
+/** List extensions available for a Webcloud Database */
+export const listHostingPrivateDatabaseDatabaseExtension: API.OperationMethod<
+  ListHostingPrivateDatabaseDatabaseExtensionRequest,
+  ListHostingPrivateDatabaseDatabaseExtensionResponse,
+  ListHostingPrivateDatabaseDatabaseExtensionError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListHostingPrivateDatabaseDatabaseExtensionRequest,
+  output: ListHostingPrivateDatabaseDatabaseExtensionResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListHostingPrivateDatabaseDumpError = OvhOpError;
+/** Get all database dump from a Web Cloud Database */
+export const listHostingPrivateDatabaseDump: API.OperationMethod<
+  ListHostingPrivateDatabaseDumpRequest,
+  ListHostingPrivateDatabaseDumpResponse,
+  ListHostingPrivateDatabaseDumpError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListHostingPrivateDatabaseDumpRequest,
+  output: ListHostingPrivateDatabaseDumpResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListHostingPrivateDatabaseLogKindError = OvhOpError;
+/** List available log kinds */
+export const listHostingPrivateDatabaseLogKind: API.OperationMethod<
+  ListHostingPrivateDatabaseLogKindRequest,
+  ListHostingPrivateDatabaseLogKindResponse,
+  ListHostingPrivateDatabaseLogKindError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListHostingPrivateDatabaseLogKindRequest,
+  output: ListHostingPrivateDatabaseLogKindResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListHostingPrivateDatabaseLogSubscriptionError = OvhOpError;
+/** List subscription IDs for Web Cloud Database */
+export const listHostingPrivateDatabaseLogSubscription: API.OperationMethod<
+  ListHostingPrivateDatabaseLogSubscriptionRequest,
+  ListHostingPrivateDatabaseLogSubscriptionResponse,
+  ListHostingPrivateDatabaseLogSubscriptionError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListHostingPrivateDatabaseLogSubscriptionRequest,
+  output: ListHostingPrivateDatabaseLogSubscriptionResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListHostingPrivateDatabaseOomError = OvhOpError;
+/** List of privatesql OOM kill */
+export const listHostingPrivateDatabaseOom: API.OperationMethod<
+  ListHostingPrivateDatabaseOomRequest,
+  ListHostingPrivateDatabaseOomResponse,
+  ListHostingPrivateDatabaseOomError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListHostingPrivateDatabaseOomRequest,
+  output: ListHostingPrivateDatabaseOomResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListHostingPrivateDatabaseTasksError = OvhOpError;
+/** List tasks for a Webcloud Database */
+export const listHostingPrivateDatabaseTasks: API.OperationMethod<
+  ListHostingPrivateDatabaseTasksRequest,
+  ListHostingPrivateDatabaseTasksResponse,
+  ListHostingPrivateDatabaseTasksError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListHostingPrivateDatabaseTasksRequest,
+  output: ListHostingPrivateDatabaseTasksResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListHostingPrivateDatabaseUserError = OvhOpError;
+/** List users on a Web Cloud Database */
+export const listHostingPrivateDatabaseUser: API.OperationMethod<
+  ListHostingPrivateDatabaseUserRequest,
+  ListHostingPrivateDatabaseUserResponse,
+  ListHostingPrivateDatabaseUserError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListHostingPrivateDatabaseUserRequest,
+  output: ListHostingPrivateDatabaseUserResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListHostingPrivateDatabaseUserGrantError = OvhOpError;
+/** Get all information about the grants for a user in a Web Cloud Database */
+export const listHostingPrivateDatabaseUserGrant: API.OperationMethod<
+  ListHostingPrivateDatabaseUserGrantRequest,
+  ListHostingPrivateDatabaseUserGrantResponse,
+  ListHostingPrivateDatabaseUserGrantError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListHostingPrivateDatabaseUserGrantRequest,
+  output: ListHostingPrivateDatabaseUserGrantResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListHostingPrivateDatabaseWebsError = OvhOpError;
+/** List linked webs */
+export const listHostingPrivateDatabaseWebs: API.OperationMethod<
+  ListHostingPrivateDatabaseWebsRequest,
+  ListHostingPrivateDatabaseWebsResponse,
+  ListHostingPrivateDatabaseWebsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListHostingPrivateDatabaseWebsRequest,
+  output: ListHostingPrivateDatabaseWebsResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListHostingPrivateDatabaseWhitelistError = OvhOpError;
+/** List whitelists on a Web Cloud Database */
+export const listHostingPrivateDatabaseWhitelist: API.OperationMethod<
+  ListHostingPrivateDatabaseWhitelistRequest,
+  ListHostingPrivateDatabaseWhitelistResponse,
+  ListHostingPrivateDatabaseWhitelistError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListHostingPrivateDatabaseWhitelistRequest,
+  output: ListHostingPrivateDatabaseWhitelistResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutHostingPrivateDatabaseError = OvhOpError;
+/** Alter a Web Cloud Database properties */
+export const putHostingPrivateDatabase: API.OperationMethod<
+  PutHostingPrivateDatabaseRequest,
+  PutHostingPrivateDatabaseResponse,
+  PutHostingPrivateDatabaseError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutHostingPrivateDatabaseRequest,
+  output: PutHostingPrivateDatabaseResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutHostingPrivateDatabaseServiceInfosError = OvhOpError;
+/** Update service information */
+export const putHostingPrivateDatabaseServiceInfos: API.OperationMethod<
+  PutHostingPrivateDatabaseServiceInfosRequest,
+  PutHostingPrivateDatabaseServiceInfosResponse,
+  PutHostingPrivateDatabaseServiceInfosError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutHostingPrivateDatabaseServiceInfosRequest,
+  output: PutHostingPrivateDatabaseServiceInfosResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutHostingPrivateDatabaseWhitelistError = OvhOpError;
+/** Update an IP whitelist in a Web Cloud Database */
+export const putHostingPrivateDatabaseWhitelist: API.OperationMethod<
+  PutHostingPrivateDatabaseWhitelistRequest,
+  PutHostingPrivateDatabaseWhitelistResponse,
+  PutHostingPrivateDatabaseWhitelistError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutHostingPrivateDatabaseWhitelistRequest,
+  output: PutHostingPrivateDatabaseWhitelistResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RestartHostingPrivateDatabaseError = OvhOpError;
+/** Restart the Web Cloud Database */
+export const restartHostingPrivateDatabase: API.OperationMethod<
+  RestartHostingPrivateDatabaseRequest,
+  HostingPrivateDatabaseTask,
+  RestartHostingPrivateDatabaseError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RestartHostingPrivateDatabaseRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RestoreHostingPrivateDatabaseDatabaseDumpError = OvhOpError;
+/** Request the restore from this dump */
+export const restoreHostingPrivateDatabaseDatabaseDump: API.OperationMethod<
+  RestoreHostingPrivateDatabaseDatabaseDumpRequest,
+  HostingPrivateDatabaseTask,
+  RestoreHostingPrivateDatabaseDatabaseDumpError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RestoreHostingPrivateDatabaseDatabaseDumpRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RestoreHostingPrivateDatabaseDumpError = OvhOpError;
+/** Restore a database dump into a Web Cloud Database */
+export const restoreHostingPrivateDatabaseDump: API.OperationMethod<
+  RestoreHostingPrivateDatabaseDumpRequest,
+  HostingPrivateDatabaseTask,
+  RestoreHostingPrivateDatabaseDumpError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RestoreHostingPrivateDatabaseDumpRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type TerminateHostingPrivateDatabaseError = OvhOpError;
+/** Ask for the termination of your service */
+export const terminateHostingPrivateDatabase: API.OperationMethod<
+  TerminateHostingPrivateDatabaseRequest,
+  TerminateHostingPrivateDatabaseResponse,
+  TerminateHostingPrivateDatabaseError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: TerminateHostingPrivateDatabaseRequest,
+  output: TerminateHostingPrivateDatabaseResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateHostingPrivateDatabaseConfigError = OvhOpError;
+/** Update the configuration of this Web Cloud Database */
+export const updateHostingPrivateDatabaseConfig: API.OperationMethod<
+  UpdateHostingPrivateDatabaseConfigRequest,
+  HostingPrivateDatabaseConfigs,
+  UpdateHostingPrivateDatabaseConfigError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateHostingPrivateDatabaseConfigRequest,
+  output: HostingPrivateDatabaseConfigs,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateHostingPrivateDatabaseUserGrantError = OvhOpError;
+/** Update the permissions of a grant for a user on a Web Cloud Database */
+export const updateHostingPrivateDatabaseUserGrant: API.OperationMethod<
+  UpdateHostingPrivateDatabaseUserGrantRequest,
+  HostingPrivateDatabaseTask,
+  UpdateHostingPrivateDatabaseUserGrantError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateHostingPrivateDatabaseUserGrantRequest,
+  output: HostingPrivateDatabaseTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));