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

package/src/services/dedicatedceph.ts

@@ -0,0 +1,2233 @@
+// 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 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 ConfirmDedicatedCephTerminationRequest {
+  /** 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 ConfirmDedicatedCephTerminationRequest = /*@__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: "/dedicated/ceph/{serviceName}/confirmTermination",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ConfirmDedicatedCephTerminationRequest",
+}) as any as S.Schema<ConfirmDedicatedCephTerminationRequest>;
+
+export type ConfirmDedicatedCephTerminationResponse = string;
+export const ConfirmDedicatedCephTerminationResponse = /*@__PURE__*/ S.suspend(
+  () => S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ConfirmDedicatedCephTerminationResponse",
+}) as any as S.Schema<ConfirmDedicatedCephTerminationResponse>;
+
+/** List of new ACLs */
+export type CreateDedicatedCephAclRequestAclListList = Array<string>;
+export const CreateDedicatedCephAclRequestAclListList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<CreateDedicatedCephAclRequestAclListList>;
+
+export interface CreateDedicatedCephAclRequest {
+  /** Service name */
+  serviceName: string;
+  /** List of new ACLs */
+  aclList: CreateDedicatedCephAclRequestAclListList;
+}
+export const CreateDedicatedCephAclRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    aclList: CreateDedicatedCephAclRequestAclListList,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/dedicated/ceph/{serviceName}/acl",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateDedicatedCephAclRequest",
+}) as any as S.Schema<CreateDedicatedCephAclRequest>;
+
+export type CreateDedicatedCephAclResponse = string;
+export const CreateDedicatedCephAclResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateDedicatedCephAclResponse",
+}) as any as S.Schema<CreateDedicatedCephAclResponse>;
+
+export interface CreateDedicatedCephChangeContactRequest {
+  /** 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 CreateDedicatedCephChangeContactRequest = /*@__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: "/dedicated/ceph/{serviceName}/changeContact",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "CreateDedicatedCephChangeContactRequest",
+}) as any as S.Schema<CreateDedicatedCephChangeContactRequest>;
+
+export type CreateDedicatedCephChangeContactResponseBodyList = Array<number>;
+export const CreateDedicatedCephChangeContactResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.Number,
+  ) as any as S.Schema<CreateDedicatedCephChangeContactResponseBodyList>;
+
+export type CreateDedicatedCephChangeContactResponse =
+  CreateDedicatedCephChangeContactResponseBodyList;
+export const CreateDedicatedCephChangeContactResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    CreateDedicatedCephChangeContactResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateDedicatedCephChangeContactResponse",
+}) as any as S.Schema<CreateDedicatedCephChangeContactResponse>;
+
+export interface CreateDedicatedCephPoolRequest {
+  /** Service name */
+  serviceName: string;
+  /** Name of the new pool */
+  poolName: string;
+}
+export const CreateDedicatedCephPoolRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    poolName: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/dedicated/ceph/{serviceName}/pool",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateDedicatedCephPoolRequest",
+}) as any as S.Schema<CreateDedicatedCephPoolRequest>;
+
+export type CreateDedicatedCephPoolResponse = string;
+export const CreateDedicatedCephPoolResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateDedicatedCephPoolResponse",
+}) as any as S.Schema<CreateDedicatedCephPoolResponse>;
+
+export interface CreateDedicatedCephPoolErasureRequest {
+  /** Service name */
+  serviceName: string;
+  /** Name of the new pool erasure */
+  poolName: string;
+}
+export const CreateDedicatedCephPoolErasureRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      poolName: S.String,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/dedicated/ceph/{serviceName}/poolErasure",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "CreateDedicatedCephPoolErasureRequest",
+}) as any as S.Schema<CreateDedicatedCephPoolErasureRequest>;
+
+export type CreateDedicatedCephPoolErasureResponse = string;
+export const CreateDedicatedCephPoolErasureResponse = /*@__PURE__*/ S.suspend(
+  () => S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateDedicatedCephPoolErasureResponse",
+}) as any as S.Schema<CreateDedicatedCephPoolErasureResponse>;
+
+/** List of IP networks */
+export type CreateDedicatedCephRadosGatewayAclRequestNetworksList =
+  Array<string>;
+export const CreateDedicatedCephRadosGatewayAclRequestNetworksList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<CreateDedicatedCephRadosGatewayAclRequestNetworksList>;
+
+export interface CreateDedicatedCephRadosGatewayAclRequest {
+  /** Service name */
+  serviceName: string;
+  /** Name */
+  name: string;
+  /** List of IP networks */
+  networks: CreateDedicatedCephRadosGatewayAclRequestNetworksList;
+}
+export const CreateDedicatedCephRadosGatewayAclRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      name: S.String.pipe(T.Label()),
+      networks: CreateDedicatedCephRadosGatewayAclRequestNetworksList,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/dedicated/ceph/{serviceName}/radosGateway/{name}/acl",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateDedicatedCephRadosGatewayAclRequest",
+  }) as any as S.Schema<CreateDedicatedCephRadosGatewayAclRequest>;
+
+/** List of IP networks */
+export type DedicatedCephRgwAclNetworksList = Array<string>;
+export const DedicatedCephRgwAclNetworksList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<DedicatedCephRgwAclNetworksList>;
+
+/** Rados Gateway IP ACL entries */
+export interface DedicatedCephRgwAcl {
+  /** List of IP networks */
+  networks: DedicatedCephRgwAclNetworksList;
+}
+export const DedicatedCephRgwAcl = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    networks: DedicatedCephRgwAclNetworksList,
+  }),
+).annotate({
+  identifier: "DedicatedCephRgwAcl",
+}) as any as S.Schema<DedicatedCephRgwAcl>;
+
+export interface CreateDedicatedCephUserRequest {
+  /** Service name */
+  serviceName: string;
+  /** Name of the new user */
+  userName: string;
+}
+export const CreateDedicatedCephUserRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    userName: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/dedicated/ceph/{serviceName}/user",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateDedicatedCephUserRequest",
+}) as any as S.Schema<CreateDedicatedCephUserRequest>;
+
+export type CreateDedicatedCephUserResponse = string;
+export const CreateDedicatedCephUserResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateDedicatedCephUserResponse",
+}) as any as S.Schema<CreateDedicatedCephUserResponse>;
+
+/** List of permissions */
+export interface DedicatedCephUserPoolPermSetAllPermissions {
+  /** Class read permission */
+  classRead?: boolean;
+  /** Class write permission */
+  classWrite?: boolean;
+  /** Execute permission */
+  execute?: boolean;
+  /** Name of Ceph pool */
+  poolName?: string;
+  /** Read permission */
+  read?: boolean;
+  /** Write permission */
+  write?: boolean;
+}
+export const DedicatedCephUserPoolPermSetAllPermissions =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      classRead: S.optional(S.Boolean),
+      classWrite: S.optional(S.Boolean),
+      execute: S.optional(S.Boolean),
+      poolName: S.optional(S.String),
+      read: S.optional(S.Boolean),
+      write: S.optional(S.Boolean),
+    }),
+  ).annotate({
+    identifier: "DedicatedCephUserPoolPermSetAllPermissions",
+  }) as any as S.Schema<DedicatedCephUserPoolPermSetAllPermissions>;
+
+/** Permissions */
+export type CreateDedicatedCephUserPoolRequestPermissionsList =
+  Array<DedicatedCephUserPoolPermSetAllPermissions>;
+export const CreateDedicatedCephUserPoolRequestPermissionsList =
+  /*@__PURE__*/ S.Array(
+    DedicatedCephUserPoolPermSetAllPermissions,
+  ) as any as S.Schema<CreateDedicatedCephUserPoolRequestPermissionsList>;
+
+export interface CreateDedicatedCephUserPoolRequest {
+  /** Service name */
+  serviceName: string;
+  /** User name */
+  userName: string;
+  /** Permissions */
+  permissions?: CreateDedicatedCephUserPoolRequestPermissionsList;
+}
+export const CreateDedicatedCephUserPoolRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    userName: S.String.pipe(T.Label()),
+    permissions: S.optional(CreateDedicatedCephUserPoolRequestPermissionsList),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/dedicated/ceph/{serviceName}/user/{userName}/pool",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateDedicatedCephUserPoolRequest",
+}) as any as S.Schema<CreateDedicatedCephUserPoolRequest>;
+
+export type CreateDedicatedCephUserPoolResponse = string;
+export const CreateDedicatedCephUserPoolResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateDedicatedCephUserPoolResponse",
+}) as any as S.Schema<CreateDedicatedCephUserPoolResponse>;
+
+export interface DeleteDedicatedCephAclRequest {
+  /** Service name */
+  serviceName: string;
+  /** Acl ID */
+  aclId: number;
+}
+export const DeleteDedicatedCephAclRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    aclId: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/dedicated/ceph/{serviceName}/acl/{aclId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteDedicatedCephAclRequest",
+}) as any as S.Schema<DeleteDedicatedCephAclRequest>;
+
+export type DeleteDedicatedCephAclResponse = string;
+export const DeleteDedicatedCephAclResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "DeleteDedicatedCephAclResponse",
+}) as any as S.Schema<DeleteDedicatedCephAclResponse>;
+
+export interface DeleteDedicatedCephCephfRequest {
+  /** Service name */
+  serviceName: string;
+  /** Fs name */
+  fsName: string;
+}
+export const DeleteDedicatedCephCephfRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    fsName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/dedicated/ceph/{serviceName}/cephfs/{fsName}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteDedicatedCephCephfRequest",
+}) as any as S.Schema<DeleteDedicatedCephCephfRequest>;
+
+export type DeleteDedicatedCephCephfResponse = string;
+export const DeleteDedicatedCephCephfResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "DeleteDedicatedCephCephfResponse",
+}) as any as S.Schema<DeleteDedicatedCephCephfResponse>;
+
+export interface DeleteDedicatedCephPoolRequest {
+  /** Service name */
+  serviceName: string;
+  /** Pool name */
+  poolName: string;
+}
+export const DeleteDedicatedCephPoolRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    poolName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/dedicated/ceph/{serviceName}/pool/{poolName}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteDedicatedCephPoolRequest",
+}) as any as S.Schema<DeleteDedicatedCephPoolRequest>;
+
+export type DeleteDedicatedCephPoolResponse = string;
+export const DeleteDedicatedCephPoolResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "DeleteDedicatedCephPoolResponse",
+}) as any as S.Schema<DeleteDedicatedCephPoolResponse>;
+
+export interface DeleteDedicatedCephUserRequest {
+  /** Service name */
+  serviceName: string;
+  /** User name */
+  userName: string;
+}
+export const DeleteDedicatedCephUserRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    userName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/dedicated/ceph/{serviceName}/user/{userName}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteDedicatedCephUserRequest",
+}) as any as S.Schema<DeleteDedicatedCephUserRequest>;
+
+export type DeleteDedicatedCephUserResponse = string;
+export const DeleteDedicatedCephUserResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "DeleteDedicatedCephUserResponse",
+}) as any as S.Schema<DeleteDedicatedCephUserResponse>;
+
+export interface DeleteDedicatedCephUserPoolRequest {
+  /** Service name */
+  serviceName: string;
+  /** User name */
+  userName: string;
+  /** Pool name */
+  poolName: string;
+}
+export const DeleteDedicatedCephUserPoolRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    userName: S.String.pipe(T.Label()),
+    poolName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/dedicated/ceph/{serviceName}/user/{userName}/pool/{poolName}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteDedicatedCephUserPoolRequest",
+}) as any as S.Schema<DeleteDedicatedCephUserPoolRequest>;
+
+export type DeleteDedicatedCephUserPoolResponse = string;
+export const DeleteDedicatedCephUserPoolResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "DeleteDedicatedCephUserPoolResponse",
+}) as any as S.Schema<DeleteDedicatedCephUserPoolResponse>;
+
+export interface DisableDedicatedCephCephfRequest {
+  /** Service name */
+  serviceName: string;
+  /** Fs name */
+  fsName: string;
+}
+export const DisableDedicatedCephCephfRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    fsName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/dedicated/ceph/{serviceName}/cephfs/{fsName}/disable",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DisableDedicatedCephCephfRequest",
+}) as any as S.Schema<DisableDedicatedCephCephfRequest>;
+
+export type DisableDedicatedCephCephfResponse = string;
+export const DisableDedicatedCephCephfResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "DisableDedicatedCephCephfResponse",
+}) as any as S.Schema<DisableDedicatedCephCephfResponse>;
+
+export interface EnableDedicatedCephCephfRequest {
+  /** Service name */
+  serviceName: string;
+  /** Fs name */
+  fsName: string;
+}
+export const EnableDedicatedCephCephfRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    fsName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/dedicated/ceph/{serviceName}/cephfs/{fsName}/enable",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "EnableDedicatedCephCephfRequest",
+}) as any as S.Schema<EnableDedicatedCephCephfRequest>;
+
+export type EnableDedicatedCephCephfResponse = string;
+export const EnableDedicatedCephCephfResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "EnableDedicatedCephCephfResponse",
+}) as any as S.Schema<EnableDedicatedCephCephfResponse>;
+
+export interface GetDedicatedCephRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const GetDedicatedCephRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/dedicated/ceph/{serviceName}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetDedicatedCephRequest",
+}) as any as S.Schema<GetDedicatedCephRequest>;
+
+/** List of CEPH monitor IPs */
+export type DedicatedCephClusterGetResponseWithIAMCephMonsList = Array<string>;
+export const DedicatedCephClusterGetResponseWithIAMCephMonsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<DedicatedCephClusterGetResponseWithIAMCephMonsList>;
+
+/** Tunables of cluster */
+export type DedicatedCephClusterGetResponseCrushTunablesEnum =
+  | "ARGONAUT"
+  | "BOBTAIL"
+  | "DEFAULT"
+  | "FIREFLY"
+  | "HAMMER"
+  | "JEWEL"
+  | "LEGACY"
+  | "OPTIMAL";
+export const DedicatedCephClusterGetResponseCrushTunablesEnum =
+  /*@__PURE__*/ S.String;
+
+/** 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>;
+
+/** State of cluster */
+export type DedicatedCephClusterGetResponseStateEnum = "ACTIVE" | "SUSPENDED";
+export const DedicatedCephClusterGetResponseStateEnum = /*@__PURE__*/ S.String;
+
+/** Status of cluster */
+export type DedicatedCephClusterGetResponseStatusEnum =
+  | "CREATING"
+  | "DELETED"
+  | "DELETING"
+  | "INSTALLED"
+  | "TASK_IN_PROGRESS";
+export const DedicatedCephClusterGetResponseStatusEnum = /*@__PURE__*/ S.String;
+
+/** Details about ceph cluster */
+export interface DedicatedCephClusterGetResponseWithIAM {
+  /** List of CEPH monitor IPs */
+  cephMons?: DedicatedCephClusterGetResponseWithIAMCephMonsList;
+  /** Used version of ceph */
+  cephVersion?: string;
+  /** Creation date */
+  createDate?: string;
+  /** Tunables of cluster */
+  crushTunables?: DedicatedCephClusterGetResponseCrushTunablesEnum;
+  /** IAM resource metadata */
+  iam?: IamResourceMetadata | null;
+  /** Name of cluster */
+  label?: string;
+  /** Name of region where cluster is located */
+  region?: string;
+  /** ID of cluster */
+  serviceName?: string;
+  /** Size of cluster in TB */
+  size?: number;
+  /** State of cluster */
+  state?: DedicatedCephClusterGetResponseStateEnum;
+  /** Status of cluster */
+  status?: DedicatedCephClusterGetResponseStatusEnum;
+  /** Last update date */
+  updateDate?: string;
+}
+export const DedicatedCephClusterGetResponseWithIAM = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      cephMons: S.optional(DedicatedCephClusterGetResponseWithIAMCephMonsList),
+      cephVersion: S.optional(S.String),
+      createDate: S.optional(S.String),
+      crushTunables: S.optional(
+        DedicatedCephClusterGetResponseCrushTunablesEnum,
+      ),
+      iam: S.optional(S.NullOr(IamResourceMetadata)),
+      label: S.optional(S.String),
+      region: S.optional(S.String),
+      serviceName: S.optional(S.String),
+      size: S.optional(S.Number),
+      state: S.optional(DedicatedCephClusterGetResponseStateEnum),
+      status: S.optional(DedicatedCephClusterGetResponseStatusEnum),
+      updateDate: S.optional(S.String),
+    }),
+).annotate({
+  identifier: "DedicatedCephClusterGetResponseWithIAM",
+}) as any as S.Schema<DedicatedCephClusterGetResponseWithIAM>;
+
+export interface GetDedicatedCephAclRequest {
+  /** Service name */
+  serviceName: string;
+  /** Acl ID */
+  aclId: number;
+}
+export const GetDedicatedCephAclRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    aclId: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/dedicated/ceph/{serviceName}/acl/{aclId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetDedicatedCephAclRequest",
+}) as any as S.Schema<GetDedicatedCephAclRequest>;
+
+/** Family of IP ACL */
+export type DedicatedCephAclGetResponseFamilyEnum = "IPV4" | "IPV6";
+export const DedicatedCephAclGetResponseFamilyEnum = /*@__PURE__*/ S.String;
+
+/** IP ACL */
+export interface DedicatedCephAclGetResponse {
+  /** Family of IP ACL */
+  family?: DedicatedCephAclGetResponseFamilyEnum;
+  /** ID of IP ACL */
+  id?: number;
+  /** IP address (e.g., 192.0.2.0) */
+  netmask?: string;
+  /** IP address (e.g., 192.0.2.0) */
+  network?: string;
+}
+export const DedicatedCephAclGetResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    family: S.optional(DedicatedCephAclGetResponseFamilyEnum),
+    id: S.optional(S.Number),
+    netmask: S.optional(S.String),
+    network: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "DedicatedCephAclGetResponse",
+}) as any as S.Schema<DedicatedCephAclGetResponse>;
+
+export interface GetDedicatedCephCephfRequest {
+  /** Service name */
+  serviceName: string;
+  /** Fs name */
+  fsName: string;
+}
+export const GetDedicatedCephCephfRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    fsName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/dedicated/ceph/{serviceName}/cephfs/{fsName}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetDedicatedCephCephfRequest",
+}) as any as S.Schema<GetDedicatedCephCephfRequest>;
+
+/** CephFS filesystem data */
+export interface DedicatedCephCephfsGetResponse {
+  /** Filesystem state */
+  enabled?: boolean;
+  /** Filesystem name */
+  fsName?: string;
+}
+export const DedicatedCephCephfsGetResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    enabled: S.optional(S.Boolean),
+    fsName: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "DedicatedCephCephfsGetResponse",
+}) as any as S.Schema<DedicatedCephCephfsGetResponse>;
+
+export interface GetDedicatedCephHealthRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const GetDedicatedCephHealthRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/dedicated/ceph/{serviceName}/health",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetDedicatedCephHealthRequest",
+}) as any as S.Schema<GetDedicatedCephHealthRequest>;
+
+/** Health of ceph cluster */
+export interface DedicatedCephClusterHealthResponse {
+  /** All available space in bytes */
+  availableBytes?: number;
+  /** True or False */
+  healthy?: boolean;
+  /** ID of cluster */
+  serviceName?: string;
+  /** Status of ceph cluster */
+  status?: string;
+  /** Total cluster space in bytes */
+  totalBytes?: number;
+  /** Used cluster space in bytes */
+  usedBytes?: number;
+}
+export const DedicatedCephClusterHealthResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    availableBytes: S.optional(S.Number),
+    healthy: S.optional(S.Boolean),
+    serviceName: S.optional(S.String),
+    status: S.optional(S.String),
+    totalBytes: S.optional(S.Number),
+    usedBytes: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "DedicatedCephClusterHealthResponse",
+}) as any as S.Schema<DedicatedCephClusterHealthResponse>;
+
+export interface GetDedicatedCephPoolRequest {
+  /** Service name */
+  serviceName: string;
+  /** Pool name */
+  poolName: string;
+}
+export const GetDedicatedCephPoolRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    poolName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/dedicated/ceph/{serviceName}/pool/{poolName}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetDedicatedCephPoolRequest",
+}) as any as S.Schema<GetDedicatedCephPoolRequest>;
+
+/** Type of pool */
+export type DedicatedCephPoolGetResponsePoolTypeEnum =
+  | "ERASURE_CODED"
+  | "REPLICATED";
+export const DedicatedCephPoolGetResponsePoolTypeEnum = /*@__PURE__*/ S.String;
+
+/** Ceph pool */
+export interface DedicatedCephPoolGetResponse {
+  /** Determine if pool should be backuped */
+  backup?: boolean;
+  /** Minimum active replicas */
+  minActiveReplicas?: number;
+  /** Name of the pool */
+  name?: string;
+  /** Type of pool */
+  poolType?: DedicatedCephPoolGetResponsePoolTypeEnum;
+  /** Number of replica */
+  replicaCount?: number;
+  /** ID of cluster */
+  serviceName?: string;
+}
+export const DedicatedCephPoolGetResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    backup: S.optional(S.Boolean),
+    minActiveReplicas: S.optional(S.Number),
+    name: S.optional(S.String),
+    poolType: S.optional(DedicatedCephPoolGetResponsePoolTypeEnum),
+    replicaCount: S.optional(S.Number),
+    serviceName: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "DedicatedCephPoolGetResponse",
+}) as any as S.Schema<DedicatedCephPoolGetResponse>;
+
+export interface GetDedicatedCephRadosGatewayRequest {
+  /** Service name */
+  serviceName: string;
+  /** Name */
+  name: string;
+}
+export const GetDedicatedCephRadosGatewayRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    name: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/dedicated/ceph/{serviceName}/radosGateway/{name}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetDedicatedCephRadosGatewayRequest",
+}) as any as S.Schema<GetDedicatedCephRadosGatewayRequest>;
+
+/** Ceph Rados Gateway data */
+export interface DedicatedCephRgwResponse {
+  /** Determines whether RGW instance is enabled or disabled. Only disabled instance can be deleted */
+  enabled?: boolean;
+  /** Name of RGW instance */
+  name?: string;
+}
+export const DedicatedCephRgwResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    enabled: S.optional(S.Boolean),
+    name: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "DedicatedCephRgwResponse",
+}) as any as S.Schema<DedicatedCephRgwResponse>;
+
+export interface GetDedicatedCephServiceInfosRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const GetDedicatedCephServiceInfosRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/dedicated/ceph/{serviceName}/serviceInfos",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetDedicatedCephServiceInfosRequest",
+}) as any as S.Schema<GetDedicatedCephServiceInfosRequest>;
+
+/** 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 GetDedicatedCephTaskRequest {
+  /** Service name */
+  serviceName: string;
+  /** Task ID */
+  taskId: string;
+}
+export const GetDedicatedCephTaskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    taskId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/dedicated/ceph/{serviceName}/task/{taskId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetDedicatedCephTaskRequest",
+}) as any as S.Schema<GetDedicatedCephTaskRequest>;
+
+/** State of task */
+export type DedicatedCephTaskGetResponseStateEnum =
+  | "DONE"
+  | "FAILED"
+  | "IN PROGRESS";
+export const DedicatedCephTaskGetResponseStateEnum = /*@__PURE__*/ S.String;
+
+/** List of task subtasks */
+export interface DedicatedCephTaskGetResponse {
+  /** Creation date of the task */
+  createDate?: string;
+  /** Finish date of the task */
+  finishDate?: string | null;
+  /** Name of the task */
+  name?: string;
+  /** State of the task */
+  state?: DedicatedCephTaskGetResponseStateEnum;
+  /** Type of the task */
+  type?: string;
+}
+export const DedicatedCephTaskGetResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    createDate: S.optional(S.String),
+    finishDate: S.optional(S.NullOr(S.String)),
+    name: S.optional(S.String),
+    state: S.optional(DedicatedCephTaskGetResponseStateEnum),
+    type: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "DedicatedCephTaskGetResponse",
+}) as any as S.Schema<DedicatedCephTaskGetResponse>;
+
+export type GetDedicatedCephTaskResponseBodyList =
+  Array<DedicatedCephTaskGetResponse>;
+export const GetDedicatedCephTaskResponseBodyList = /*@__PURE__*/ S.Array(
+  DedicatedCephTaskGetResponse,
+) as any as S.Schema<GetDedicatedCephTaskResponseBodyList>;
+
+export type GetDedicatedCephTaskResponse = GetDedicatedCephTaskResponseBodyList;
+export const GetDedicatedCephTaskResponse = /*@__PURE__*/ S.suspend(() =>
+  GetDedicatedCephTaskResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetDedicatedCephTaskResponse",
+}) as any as S.Schema<GetDedicatedCephTaskResponse>;
+
+export interface GetDedicatedCephUserRequest {
+  /** Service name */
+  serviceName: string;
+  /** User name */
+  userName: string;
+}
+export const GetDedicatedCephUserRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    userName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/dedicated/ceph/{serviceName}/user/{userName}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetDedicatedCephUserRequest",
+}) as any as S.Schema<GetDedicatedCephUserRequest>;
+
+/** Ceph user */
+export interface DedicatedCephUserGetResponse {
+  /** Key of user to connect into cluster */
+  key?: string;
+  /** Capabilities of user on MDS */
+  mdsCaps?: string | null;
+  /** Capabilities of user on MON */
+  monCaps?: string;
+  /** Name of ceph user */
+  name?: string;
+  /** Capabilities of user on OSD */
+  osdCaps?: string;
+  /** ID of cluster */
+  serviceName?: string;
+}
+export const DedicatedCephUserGetResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    key: S.optional(S.String),
+    mdsCaps: S.optional(S.NullOr(S.String)),
+    monCaps: S.optional(S.String),
+    name: S.optional(S.String),
+    osdCaps: S.optional(S.String),
+    serviceName: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "DedicatedCephUserGetResponse",
+}) as any as S.Schema<DedicatedCephUserGetResponse>;
+
+/** 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 ListDedicatedCephRequestIamTagsValueList =
+  Array<IamResourceTagFilterInput>;
+export const ListDedicatedCephRequestIamTagsValueList = /*@__PURE__*/ S.Array(
+  IamResourceTagFilterInput,
+) as any as S.Schema<ListDedicatedCephRequestIamTagsValueList>;
+
+export type ListDedicatedCephRequestIamTagsMap = {
+  [key: string]: ListDedicatedCephRequestIamTagsValueList | undefined;
+};
+export const ListDedicatedCephRequestIamTagsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  ListDedicatedCephRequestIamTagsValueList,
+) as any as S.Schema<ListDedicatedCephRequestIamTagsMap>;
+
+export interface ListDedicatedCephRequest {
+  /** Filter resources on IAM tags */
+  iamTags?: ListDedicatedCephRequestIamTagsMap;
+}
+export const ListDedicatedCephRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    iamTags: S.optional(ListDedicatedCephRequestIamTagsMap.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/dedicated/ceph", code: 200 })),
+).annotate({
+  identifier: "ListDedicatedCephRequest",
+}) as any as S.Schema<ListDedicatedCephRequest>;
+
+export type ListDedicatedCephResponseBodyList = Array<string>;
+export const ListDedicatedCephResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListDedicatedCephResponseBodyList>;
+
+export type ListDedicatedCephResponse = ListDedicatedCephResponseBodyList;
+export const ListDedicatedCephResponse = /*@__PURE__*/ S.suspend(() =>
+  ListDedicatedCephResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListDedicatedCephResponse",
+}) as any as S.Schema<ListDedicatedCephResponse>;
+
+export interface ListDedicatedCephAclRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const ListDedicatedCephAclRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/dedicated/ceph/{serviceName}/acl",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListDedicatedCephAclRequest",
+}) as any as S.Schema<ListDedicatedCephAclRequest>;
+
+export type ListDedicatedCephAclResponseBodyList =
+  Array<DedicatedCephAclGetResponse>;
+export const ListDedicatedCephAclResponseBodyList = /*@__PURE__*/ S.Array(
+  DedicatedCephAclGetResponse,
+) as any as S.Schema<ListDedicatedCephAclResponseBodyList>;
+
+export type ListDedicatedCephAclResponse = ListDedicatedCephAclResponseBodyList;
+export const ListDedicatedCephAclResponse = /*@__PURE__*/ S.suspend(() =>
+  ListDedicatedCephAclResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListDedicatedCephAclResponse",
+}) as any as S.Schema<ListDedicatedCephAclResponse>;
+
+export interface ListDedicatedCephCephfsRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const ListDedicatedCephCephfsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/dedicated/ceph/{serviceName}/cephfs",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListDedicatedCephCephfsRequest",
+}) as any as S.Schema<ListDedicatedCephCephfsRequest>;
+
+export type ListDedicatedCephCephfsResponseBodyList =
+  Array<DedicatedCephCephfsGetResponse>;
+export const ListDedicatedCephCephfsResponseBodyList = /*@__PURE__*/ S.Array(
+  DedicatedCephCephfsGetResponse,
+) as any as S.Schema<ListDedicatedCephCephfsResponseBodyList>;
+
+export type ListDedicatedCephCephfsResponse =
+  ListDedicatedCephCephfsResponseBodyList;
+export const ListDedicatedCephCephfsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListDedicatedCephCephfsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListDedicatedCephCephfsResponse",
+}) as any as S.Schema<ListDedicatedCephCephfsResponse>;
+
+export interface ListDedicatedCephPoolRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const ListDedicatedCephPoolRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/dedicated/ceph/{serviceName}/pool",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListDedicatedCephPoolRequest",
+}) as any as S.Schema<ListDedicatedCephPoolRequest>;
+
+export type ListDedicatedCephPoolResponseBodyList =
+  Array<DedicatedCephPoolGetResponse>;
+export const ListDedicatedCephPoolResponseBodyList = /*@__PURE__*/ S.Array(
+  DedicatedCephPoolGetResponse,
+) as any as S.Schema<ListDedicatedCephPoolResponseBodyList>;
+
+export type ListDedicatedCephPoolResponse =
+  ListDedicatedCephPoolResponseBodyList;
+export const ListDedicatedCephPoolResponse = /*@__PURE__*/ S.suspend(() =>
+  ListDedicatedCephPoolResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListDedicatedCephPoolResponse",
+}) as any as S.Schema<ListDedicatedCephPoolResponse>;
+
+export interface ListDedicatedCephRadosGatewayRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const ListDedicatedCephRadosGatewayRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/dedicated/ceph/{serviceName}/radosGateway",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListDedicatedCephRadosGatewayRequest",
+}) as any as S.Schema<ListDedicatedCephRadosGatewayRequest>;
+
+export type ListDedicatedCephRadosGatewayResponseBodyList =
+  Array<DedicatedCephRgwResponse>;
+export const ListDedicatedCephRadosGatewayResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    DedicatedCephRgwResponse,
+  ) as any as S.Schema<ListDedicatedCephRadosGatewayResponseBodyList>;
+
+export type ListDedicatedCephRadosGatewayResponse =
+  ListDedicatedCephRadosGatewayResponseBodyList;
+export const ListDedicatedCephRadosGatewayResponse = /*@__PURE__*/ S.suspend(
+  () => ListDedicatedCephRadosGatewayResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListDedicatedCephRadosGatewayResponse",
+}) as any as S.Schema<ListDedicatedCephRadosGatewayResponse>;
+
+export interface ListDedicatedCephRadosGatewayAclRequest {
+  /** Service name */
+  serviceName: string;
+  /** Name */
+  name: string;
+}
+export const ListDedicatedCephRadosGatewayAclRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      name: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/dedicated/ceph/{serviceName}/radosGateway/{name}/acl",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListDedicatedCephRadosGatewayAclRequest",
+}) as any as S.Schema<ListDedicatedCephRadosGatewayAclRequest>;
+
+export interface ListDedicatedCephTaskRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const ListDedicatedCephTaskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/dedicated/ceph/{serviceName}/task",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListDedicatedCephTaskRequest",
+}) as any as S.Schema<ListDedicatedCephTaskRequest>;
+
+/** List of active tasks */
+export interface DedicatedCephTaskListResponse {
+  /** ID of task */
+  id?: string;
+  /** Name of task */
+  name?: string;
+}
+export const DedicatedCephTaskListResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.optional(S.String),
+    name: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "DedicatedCephTaskListResponse",
+}) as any as S.Schema<DedicatedCephTaskListResponse>;
+
+export type ListDedicatedCephTaskResponseBodyList =
+  Array<DedicatedCephTaskListResponse>;
+export const ListDedicatedCephTaskResponseBodyList = /*@__PURE__*/ S.Array(
+  DedicatedCephTaskListResponse,
+) as any as S.Schema<ListDedicatedCephTaskResponseBodyList>;
+
+export type ListDedicatedCephTaskResponse =
+  ListDedicatedCephTaskResponseBodyList;
+export const ListDedicatedCephTaskResponse = /*@__PURE__*/ S.suspend(() =>
+  ListDedicatedCephTaskResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListDedicatedCephTaskResponse",
+}) as any as S.Schema<ListDedicatedCephTaskResponse>;
+
+export interface ListDedicatedCephUserRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const ListDedicatedCephUserRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/dedicated/ceph/{serviceName}/user",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListDedicatedCephUserRequest",
+}) as any as S.Schema<ListDedicatedCephUserRequest>;
+
+export type ListDedicatedCephUserResponseBodyList =
+  Array<DedicatedCephUserGetResponse>;
+export const ListDedicatedCephUserResponseBodyList = /*@__PURE__*/ S.Array(
+  DedicatedCephUserGetResponse,
+) as any as S.Schema<ListDedicatedCephUserResponseBodyList>;
+
+export type ListDedicatedCephUserResponse =
+  ListDedicatedCephUserResponseBodyList;
+export const ListDedicatedCephUserResponse = /*@__PURE__*/ S.suspend(() =>
+  ListDedicatedCephUserResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListDedicatedCephUserResponse",
+}) as any as S.Schema<ListDedicatedCephUserResponse>;
+
+export interface ListDedicatedCephUserPoolRequest {
+  /** Service name */
+  serviceName: string;
+  /** User name */
+  userName: string;
+}
+export const ListDedicatedCephUserPoolRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    userName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/dedicated/ceph/{serviceName}/user/{userName}/pool",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListDedicatedCephUserPoolRequest",
+}) as any as S.Schema<ListDedicatedCephUserPoolRequest>;
+
+/** List of permissions */
+export type DedicatedCephUserPoolPermListResponse =
+  DedicatedCephUserPoolPermSetAllPermissions;
+export const DedicatedCephUserPoolPermListResponse =
+  DedicatedCephUserPoolPermSetAllPermissions;
+
+export type ListDedicatedCephUserPoolResponseBodyList =
+  Array<DedicatedCephUserPoolPermSetAllPermissions>;
+export const ListDedicatedCephUserPoolResponseBodyList = /*@__PURE__*/ S.Array(
+  DedicatedCephUserPoolPermSetAllPermissions,
+) as any as S.Schema<ListDedicatedCephUserPoolResponseBodyList>;
+
+export type ListDedicatedCephUserPoolResponse =
+  ListDedicatedCephUserPoolResponseBodyList;
+export const ListDedicatedCephUserPoolResponse = /*@__PURE__*/ S.suspend(() =>
+  ListDedicatedCephUserPoolResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListDedicatedCephUserPoolResponse",
+}) as any as S.Schema<ListDedicatedCephUserPoolResponse>;
+
+/** Tunables of cluster */
+export type DedicatedCephClusterUpdateCrushTunablesEnum =
+  | "ARGONAUT"
+  | "BOBTAIL"
+  | "DEFAULT"
+  | "FIREFLY"
+  | "HAMMER"
+  | "JEWEL"
+  | "LEGACY"
+  | "OPTIMAL";
+export const DedicatedCephClusterUpdateCrushTunablesEnum =
+  /*@__PURE__*/ S.String;
+
+export interface PutDedicatedCephRequest {
+  /** Service name */
+  serviceName: string;
+  /** Tunables of cluster */
+  crushTunables: DedicatedCephClusterUpdateCrushTunablesEnum | (string & {});
+  /** Name of the cluster */
+  label: string;
+}
+export const PutDedicatedCephRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    crushTunables: DedicatedCephClusterUpdateCrushTunablesEnum,
+    label: S.String,
+  }).pipe(
+    T.Http({ method: "PUT", uri: "/dedicated/ceph/{serviceName}", code: 200 }),
+  ),
+).annotate({
+  identifier: "PutDedicatedCephRequest",
+}) as any as S.Schema<PutDedicatedCephRequest>;
+
+export type PutDedicatedCephResponse = string;
+export const PutDedicatedCephResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "PutDedicatedCephResponse",
+}) as any as S.Schema<PutDedicatedCephResponse>;
+
+export interface PutDedicatedCephPoolAllowDeletionRequest {
+  /** Service name */
+  serviceName: string;
+  /** Pool name */
+  poolName: string;
+}
+export const PutDedicatedCephPoolAllowDeletionRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      poolName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "PUT",
+        uri: "/dedicated/ceph/{serviceName}/pool/{poolName}/allowDeletion",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "PutDedicatedCephPoolAllowDeletionRequest",
+}) as any as S.Schema<PutDedicatedCephPoolAllowDeletionRequest>;
+
+export type PutDedicatedCephPoolAllowDeletionResponse = string;
+export const PutDedicatedCephPoolAllowDeletionResponse =
+  /*@__PURE__*/ S.suspend(() => S.String.pipe(T.RawResponseRoot())).annotate({
+    identifier: "PutDedicatedCephPoolAllowDeletionResponse",
+  }) as any as S.Schema<PutDedicatedCephPoolAllowDeletionResponse>;
+
+/** List of IP networks */
+export type PutDedicatedCephRadosGatewayAclRequestNetworksList = Array<string>;
+export const PutDedicatedCephRadosGatewayAclRequestNetworksList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<PutDedicatedCephRadosGatewayAclRequestNetworksList>;
+
+export interface PutDedicatedCephRadosGatewayAclRequest {
+  /** Service name */
+  serviceName: string;
+  /** Name */
+  name: string;
+  /** List of IP networks */
+  networks: PutDedicatedCephRadosGatewayAclRequestNetworksList;
+}
+export const PutDedicatedCephRadosGatewayAclRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      name: S.String.pipe(T.Label()),
+      networks: PutDedicatedCephRadosGatewayAclRequestNetworksList,
+    }).pipe(
+      T.Http({
+        method: "PUT",
+        uri: "/dedicated/ceph/{serviceName}/radosGateway/{name}/acl",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "PutDedicatedCephRadosGatewayAclRequest",
+}) as any as S.Schema<PutDedicatedCephRadosGatewayAclRequest>;
+
+export interface PutDedicatedCephServiceInfosRequest {
+  /** Service name */
+  serviceName: string;
+  /** Way of handling the renew */
+  renew?: ServiceRenewType | null;
+}
+export const PutDedicatedCephServiceInfosRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    renew: S.optional(S.NullOr(ServiceRenewType)),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/dedicated/ceph/{serviceName}/serviceInfos",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutDedicatedCephServiceInfosRequest",
+}) as any as S.Schema<PutDedicatedCephServiceInfosRequest>;
+
+export interface PutDedicatedCephServiceInfosResponse {}
+export const PutDedicatedCephServiceInfosResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "PutDedicatedCephServiceInfosResponse",
+}) as any as S.Schema<PutDedicatedCephServiceInfosResponse>;
+
+export interface PutDedicatedCephUserPoolRequest {
+  /** Service name */
+  serviceName: string;
+  /** User name */
+  userName: string;
+  /** Class read permission */
+  classRead: boolean;
+  /** Class write permission */
+  classWrite: boolean;
+  /** Execute permission */
+  execute: boolean;
+  /** Name of Ceph pool */
+  poolName: string;
+  /** Read permission */
+  read: boolean;
+  /** Write permission */
+  write: boolean;
+}
+export const PutDedicatedCephUserPoolRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    userName: S.String.pipe(T.Label()),
+    classRead: S.Boolean,
+    classWrite: S.Boolean,
+    execute: S.Boolean,
+    poolName: S.String,
+    read: S.Boolean,
+    write: S.Boolean,
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/dedicated/ceph/{serviceName}/user/{userName}/pool",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutDedicatedCephUserPoolRequest",
+}) as any as S.Schema<PutDedicatedCephUserPoolRequest>;
+
+export type PutDedicatedCephUserPoolResponse = string;
+export const PutDedicatedCephUserPoolResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "PutDedicatedCephUserPoolResponse",
+}) as any as S.Schema<PutDedicatedCephUserPoolResponse>;
+
+export interface TerminateDedicatedCephRequest {
+  /** Service name */
+  serviceName: string;
+}
+export const TerminateDedicatedCephRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/dedicated/ceph/{serviceName}/terminate",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "TerminateDedicatedCephRequest",
+}) as any as S.Schema<TerminateDedicatedCephRequest>;
+
+export type TerminateDedicatedCephResponse = string;
+export const TerminateDedicatedCephResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "TerminateDedicatedCephResponse",
+}) as any as S.Schema<TerminateDedicatedCephResponse>;
+
+export type ConfirmDedicatedCephTerminationError = OvhOpError;
+/** Confirm service termination */
+export const confirmDedicatedCephTermination: API.OperationMethod<
+  ConfirmDedicatedCephTerminationRequest,
+  ConfirmDedicatedCephTerminationResponse,
+  ConfirmDedicatedCephTerminationError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ConfirmDedicatedCephTerminationRequest,
+  output: ConfirmDedicatedCephTerminationResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateDedicatedCephAclError = OvhOpError;
+/** Create one or more new IP ACLs */
+export const createDedicatedCephAcl: API.OperationMethod<
+  CreateDedicatedCephAclRequest,
+  CreateDedicatedCephAclResponse,
+  CreateDedicatedCephAclError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateDedicatedCephAclRequest,
+  output: CreateDedicatedCephAclResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateDedicatedCephChangeContactError = OvhOpError;
+/** Launch a contact change procedure */
+export const createDedicatedCephChangeContact: API.OperationMethod<
+  CreateDedicatedCephChangeContactRequest,
+  CreateDedicatedCephChangeContactResponse,
+  CreateDedicatedCephChangeContactError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateDedicatedCephChangeContactRequest,
+  output: CreateDedicatedCephChangeContactResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateDedicatedCephPoolError = OvhOpError;
+/** Create a new ceph pool */
+export const createDedicatedCephPool: API.OperationMethod<
+  CreateDedicatedCephPoolRequest,
+  CreateDedicatedCephPoolResponse,
+  CreateDedicatedCephPoolError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateDedicatedCephPoolRequest,
+  output: CreateDedicatedCephPoolResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateDedicatedCephPoolErasureError = OvhOpError;
+/** Create a new ceph erasure pool */
+export const createDedicatedCephPoolErasure: API.OperationMethod<
+  CreateDedicatedCephPoolErasureRequest,
+  CreateDedicatedCephPoolErasureResponse,
+  CreateDedicatedCephPoolErasureError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateDedicatedCephPoolErasureRequest,
+  output: CreateDedicatedCephPoolErasureResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateDedicatedCephRadosGatewayAclError = OvhOpError;
+/** Add Rados Gateway ACL entries, any given network must be unique */
+export const createDedicatedCephRadosGatewayAcl: API.OperationMethod<
+  CreateDedicatedCephRadosGatewayAclRequest,
+  DedicatedCephRgwAcl,
+  CreateDedicatedCephRadosGatewayAclError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateDedicatedCephRadosGatewayAclRequest,
+  output: DedicatedCephRgwAcl,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateDedicatedCephUserError = OvhOpError;
+/** Create a new ceph user */
+export const createDedicatedCephUser: API.OperationMethod<
+  CreateDedicatedCephUserRequest,
+  CreateDedicatedCephUserResponse,
+  CreateDedicatedCephUserError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateDedicatedCephUserRequest,
+  output: CreateDedicatedCephUserResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateDedicatedCephUserPoolError = OvhOpError;
+/** Create new user-pool permissions. All old permissions will be cleared */
+export const createDedicatedCephUserPool: API.OperationMethod<
+  CreateDedicatedCephUserPoolRequest,
+  CreateDedicatedCephUserPoolResponse,
+  CreateDedicatedCephUserPoolError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateDedicatedCephUserPoolRequest,
+  output: CreateDedicatedCephUserPoolResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteDedicatedCephAclError = OvhOpError;
+/** Delete single IP ACL */
+export const deleteDedicatedCephAcl: API.OperationMethod<
+  DeleteDedicatedCephAclRequest,
+  DeleteDedicatedCephAclResponse,
+  DeleteDedicatedCephAclError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteDedicatedCephAclRequest,
+  output: DeleteDedicatedCephAclResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteDedicatedCephCephfError = OvhOpError;
+/** Purge CephFS filesystem */
+export const deleteDedicatedCephCephf: API.OperationMethod<
+  DeleteDedicatedCephCephfRequest,
+  DeleteDedicatedCephCephfResponse,
+  DeleteDedicatedCephCephfError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteDedicatedCephCephfRequest,
+  output: DeleteDedicatedCephCephfResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteDedicatedCephPoolError = OvhOpError;
+/** Delete a single ceph pool */
+export const deleteDedicatedCephPool: API.OperationMethod<
+  DeleteDedicatedCephPoolRequest,
+  DeleteDedicatedCephPoolResponse,
+  DeleteDedicatedCephPoolError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteDedicatedCephPoolRequest,
+  output: DeleteDedicatedCephPoolResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteDedicatedCephUserError = OvhOpError;
+/** Delete an existing single ceph user */
+export const deleteDedicatedCephUser: API.OperationMethod<
+  DeleteDedicatedCephUserRequest,
+  DeleteDedicatedCephUserResponse,
+  DeleteDedicatedCephUserError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteDedicatedCephUserRequest,
+  output: DeleteDedicatedCephUserResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteDedicatedCephUserPoolError = OvhOpError;
+/** Clear user-pool permission for single pool */
+export const deleteDedicatedCephUserPool: API.OperationMethod<
+  DeleteDedicatedCephUserPoolRequest,
+  DeleteDedicatedCephUserPoolResponse,
+  DeleteDedicatedCephUserPoolError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteDedicatedCephUserPoolRequest,
+  output: DeleteDedicatedCephUserPoolResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DisableDedicatedCephCephfError = OvhOpError;
+/** Disable CephFS filesystem */
+export const disableDedicatedCephCephf: API.OperationMethod<
+  DisableDedicatedCephCephfRequest,
+  DisableDedicatedCephCephfResponse,
+  DisableDedicatedCephCephfError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DisableDedicatedCephCephfRequest,
+  output: DisableDedicatedCephCephfResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EnableDedicatedCephCephfError = OvhOpError;
+/** Enable CephFS filesystem */
+export const enableDedicatedCephCephf: API.OperationMethod<
+  EnableDedicatedCephCephfRequest,
+  EnableDedicatedCephCephfResponse,
+  EnableDedicatedCephCephfError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EnableDedicatedCephCephfRequest,
+  output: EnableDedicatedCephCephfResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetDedicatedCephError = OvhOpError;
+/** Get cluster details */
+export const getDedicatedCeph: API.OperationMethod<
+  GetDedicatedCephRequest,
+  DedicatedCephClusterGetResponseWithIAM,
+  GetDedicatedCephError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetDedicatedCephRequest,
+  output: DedicatedCephClusterGetResponseWithIAM,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetDedicatedCephAclError = OvhOpError;
+/** Get details about IP ACL */
+export const getDedicatedCephAcl: API.OperationMethod<
+  GetDedicatedCephAclRequest,
+  DedicatedCephAclGetResponse,
+  GetDedicatedCephAclError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetDedicatedCephAclRequest,
+  output: DedicatedCephAclGetResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetDedicatedCephCephfError = OvhOpError;
+/** Get CephFS filesystem information */
+export const getDedicatedCephCephf: API.OperationMethod<
+  GetDedicatedCephCephfRequest,
+  DedicatedCephCephfsGetResponse,
+  GetDedicatedCephCephfError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetDedicatedCephCephfRequest,
+  output: DedicatedCephCephfsGetResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetDedicatedCephHealthError = OvhOpError;
+/** Get cluster health */
+export const getDedicatedCephHealth: API.OperationMethod<
+  GetDedicatedCephHealthRequest,
+  DedicatedCephClusterHealthResponse,
+  GetDedicatedCephHealthError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetDedicatedCephHealthRequest,
+  output: DedicatedCephClusterHealthResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetDedicatedCephPoolError = OvhOpError;
+/** Get details about an existing ceph pool */
+export const getDedicatedCephPool: API.OperationMethod<
+  GetDedicatedCephPoolRequest,
+  DedicatedCephPoolGetResponse,
+  GetDedicatedCephPoolError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetDedicatedCephPoolRequest,
+  output: DedicatedCephPoolGetResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetDedicatedCephRadosGatewayError = OvhOpError;
+export const getDedicatedCephRadosGateway: API.OperationMethod<
+  GetDedicatedCephRadosGatewayRequest,
+  DedicatedCephRgwResponse,
+  GetDedicatedCephRadosGatewayError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetDedicatedCephRadosGatewayRequest,
+  output: DedicatedCephRgwResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetDedicatedCephServiceInfosError = OvhOpError;
+/** Get service information */
+export const getDedicatedCephServiceInfos: API.OperationMethod<
+  GetDedicatedCephServiceInfosRequest,
+  ServicesService,
+  GetDedicatedCephServiceInfosError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetDedicatedCephServiceInfosRequest,
+  output: ServicesService,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetDedicatedCephTaskError = OvhOpError;
+/** Get task details */
+export const getDedicatedCephTask: API.OperationMethod<
+  GetDedicatedCephTaskRequest,
+  GetDedicatedCephTaskResponse,
+  GetDedicatedCephTaskError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetDedicatedCephTaskRequest,
+  output: GetDedicatedCephTaskResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetDedicatedCephUserError = OvhOpError;
+/** Get details about a ceph user */
+export const getDedicatedCephUser: API.OperationMethod<
+  GetDedicatedCephUserRequest,
+  DedicatedCephUserGetResponse,
+  GetDedicatedCephUserError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetDedicatedCephUserRequest,
+  output: DedicatedCephUserGetResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListDedicatedCephError = OvhOpError;
+/** List available services */
+export const listDedicatedCeph: API.OperationMethod<
+  ListDedicatedCephRequest,
+  ListDedicatedCephResponse,
+  ListDedicatedCephError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListDedicatedCephRequest,
+  output: ListDedicatedCephResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListDedicatedCephAclError = OvhOpError;
+/** Get list of all IP ACLs in a cluster */
+export const listDedicatedCephAcl: API.OperationMethod<
+  ListDedicatedCephAclRequest,
+  ListDedicatedCephAclResponse,
+  ListDedicatedCephAclError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListDedicatedCephAclRequest,
+  output: ListDedicatedCephAclResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListDedicatedCephCephfsError = OvhOpError;
+/** List CephFS filesystems */
+export const listDedicatedCephCephfs: API.OperationMethod<
+  ListDedicatedCephCephfsRequest,
+  ListDedicatedCephCephfsResponse,
+  ListDedicatedCephCephfsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListDedicatedCephCephfsRequest,
+  output: ListDedicatedCephCephfsResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListDedicatedCephPoolError = OvhOpError;
+/** Get list of all pools in a cluster */
+export const listDedicatedCephPool: API.OperationMethod<
+  ListDedicatedCephPoolRequest,
+  ListDedicatedCephPoolResponse,
+  ListDedicatedCephPoolError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListDedicatedCephPoolRequest,
+  output: ListDedicatedCephPoolResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListDedicatedCephRadosGatewayError = OvhOpError;
+/** List Ceph RGW instances */
+export const listDedicatedCephRadosGateway: API.OperationMethod<
+  ListDedicatedCephRadosGatewayRequest,
+  ListDedicatedCephRadosGatewayResponse,
+  ListDedicatedCephRadosGatewayError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListDedicatedCephRadosGatewayRequest,
+  output: ListDedicatedCephRadosGatewayResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListDedicatedCephRadosGatewayAclError = OvhOpError;
+/** Get all Rados Gateway ACL entries */
+export const listDedicatedCephRadosGatewayAcl: API.OperationMethod<
+  ListDedicatedCephRadosGatewayAclRequest,
+  DedicatedCephRgwAcl,
+  ListDedicatedCephRadosGatewayAclError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListDedicatedCephRadosGatewayAclRequest,
+  output: DedicatedCephRgwAcl,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListDedicatedCephTaskError = OvhOpError;
+/** List tasks in progress */
+export const listDedicatedCephTask: API.OperationMethod<
+  ListDedicatedCephTaskRequest,
+  ListDedicatedCephTaskResponse,
+  ListDedicatedCephTaskError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListDedicatedCephTaskRequest,
+  output: ListDedicatedCephTaskResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListDedicatedCephUserError = OvhOpError;
+/** Get list of all users in a cluster */
+export const listDedicatedCephUser: API.OperationMethod<
+  ListDedicatedCephUserRequest,
+  ListDedicatedCephUserResponse,
+  ListDedicatedCephUserError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListDedicatedCephUserRequest,
+  output: ListDedicatedCephUserResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListDedicatedCephUserPoolError = OvhOpError;
+/** List user-pool permissions */
+export const listDedicatedCephUserPool: API.OperationMethod<
+  ListDedicatedCephUserPoolRequest,
+  ListDedicatedCephUserPoolResponse,
+  ListDedicatedCephUserPoolError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListDedicatedCephUserPoolRequest,
+  output: ListDedicatedCephUserPoolResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutDedicatedCephError = OvhOpError;
+/** Update cluster details */
+export const putDedicatedCeph: API.OperationMethod<
+  PutDedicatedCephRequest,
+  PutDedicatedCephResponse,
+  PutDedicatedCephError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutDedicatedCephRequest,
+  output: PutDedicatedCephResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutDedicatedCephPoolAllowDeletionError = OvhOpError;
+/** Open 5 minutes window for deleting single ceph pool */
+export const putDedicatedCephPoolAllowDeletion: API.OperationMethod<
+  PutDedicatedCephPoolAllowDeletionRequest,
+  PutDedicatedCephPoolAllowDeletionResponse,
+  PutDedicatedCephPoolAllowDeletionError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutDedicatedCephPoolAllowDeletionRequest,
+  output: PutDedicatedCephPoolAllowDeletionResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutDedicatedCephRadosGatewayAclError = OvhOpError;
+/** Completely replaces Rados Gateway ACL entries */
+export const putDedicatedCephRadosGatewayAcl: API.OperationMethod<
+  PutDedicatedCephRadosGatewayAclRequest,
+  DedicatedCephRgwAcl,
+  PutDedicatedCephRadosGatewayAclError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutDedicatedCephRadosGatewayAclRequest,
+  output: DedicatedCephRgwAcl,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutDedicatedCephServiceInfosError = OvhOpError;
+/** Update service information */
+export const putDedicatedCephServiceInfos: API.OperationMethod<
+  PutDedicatedCephServiceInfosRequest,
+  PutDedicatedCephServiceInfosResponse,
+  PutDedicatedCephServiceInfosError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutDedicatedCephServiceInfosRequest,
+  output: PutDedicatedCephServiceInfosResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutDedicatedCephUserPoolError = OvhOpError;
+/** Update user-pool permission for single pool */
+export const putDedicatedCephUserPool: API.OperationMethod<
+  PutDedicatedCephUserPoolRequest,
+  PutDedicatedCephUserPoolResponse,
+  PutDedicatedCephUserPoolError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutDedicatedCephUserPoolRequest,
+  output: PutDedicatedCephUserPoolResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type TerminateDedicatedCephError = OvhOpError;
+/** Ask for the termination of your service */
+export const terminateDedicatedCeph: API.OperationMethod<
+  TerminateDedicatedCephRequest,
+  TerminateDedicatedCephResponse,
+  TerminateDedicatedCephError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: TerminateDedicatedCephRequest,
+  output: TerminateDedicatedCephResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));