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

package/src/services/dedicatednasha.ts

@@ -0,0 +1,2269 @@
+// 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 ConfirmDedicatedNashaTerminationRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** Commentary about your termination request */
+  commentary?: string;
+  /** What next after your termination request */
+  futureUse?: ServiceTerminationFutureUseEnum | (string & {});
+  /** Reason of your termination request */
+  reason?: ServiceTerminationReasonEnum | (string & {});
+  /** The termination token sent by email to the admin contact */
+  token: string;
+}
+export const ConfirmDedicatedNashaTerminationRequest = /*@__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/nasha/{serviceName}/confirmTermination",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ConfirmDedicatedNashaTerminationRequest",
+}) as any as S.Schema<ConfirmDedicatedNashaTerminationRequest>;
+
+export type ConfirmDedicatedNashaTerminationResponse = string;
+export const ConfirmDedicatedNashaTerminationResponse = /*@__PURE__*/ S.suspend(
+  () => S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ConfirmDedicatedNashaTerminationResponse",
+}) as any as S.Schema<ConfirmDedicatedNashaTerminationResponse>;
+
+export interface CreateDedicatedNashaChangeContactRequest {
+  /** The internal name of your storage */
+  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 CreateDedicatedNashaChangeContactRequest = /*@__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/nasha/{serviceName}/changeContact",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "CreateDedicatedNashaChangeContactRequest",
+}) as any as S.Schema<CreateDedicatedNashaChangeContactRequest>;
+
+export type CreateDedicatedNashaChangeContactResponseBodyList = Array<number>;
+export const CreateDedicatedNashaChangeContactResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.Number,
+  ) as any as S.Schema<CreateDedicatedNashaChangeContactResponseBodyList>;
+
+export type CreateDedicatedNashaChangeContactResponse =
+  CreateDedicatedNashaChangeContactResponseBodyList;
+export const CreateDedicatedNashaChangeContactResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    CreateDedicatedNashaChangeContactResponseBodyList.pipe(T.RawResponseRoot()),
+  ).annotate({
+    identifier: "CreateDedicatedNashaChangeContactResponse",
+  }) as any as S.Schema<CreateDedicatedNashaChangeContactResponse>;
+
+/** Partition Protocol */
+export type DedicatedStorageProtocolEnum = "CIFS" | "NFS" | "NFS_CIFS";
+export const DedicatedStorageProtocolEnum = /*@__PURE__*/ S.String;
+
+export interface CreateDedicatedNashaPartitionRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** Partition description */
+  partitionDescription?: string;
+  /** Partition name */
+  partitionName: string;
+  /** NFS|CIFS|NFS_CIFS */
+  protocol: DedicatedStorageProtocolEnum | (string & {});
+  /** Partition size */
+  size: number;
+}
+export const CreateDedicatedNashaPartitionRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionDescription: S.optional(S.String),
+      partitionName: S.String,
+      protocol: DedicatedStorageProtocolEnum,
+      size: S.Number,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/dedicated/nasha/{serviceName}/partition",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "CreateDedicatedNashaPartitionRequest",
+}) as any as S.Schema<CreateDedicatedNashaPartitionRequest>;
+
+/** Distincts task */
+export type DedicatedStorageTaskFunctionEnum =
+  | "backupRecursiveDestroy"
+  | "clusterLeclercAclUpdate"
+  | "clusterLeclercChangeServiceIp"
+  | "clusterLeclercCustomSnapCreate"
+  | "clusterLeclercCustomSnapDelete"
+  | "clusterLeclercDeleteSnapshotDirectory"
+  | "clusterLeclercDestroyNasContainer"
+  | "clusterLeclercPartitionAdd"
+  | "clusterLeclercPartitionDelete"
+  | "clusterLeclercPartitionUpdate"
+  | "clusterLeclercQuotaUpdate"
+  | "clusterLeclercSetupNasContainer"
+  | "clusterLeclercSnapshotUpdate"
+  | "clusterLeclercZfsOptions"
+  | "nasAclUpdate"
+  | "nasDeleteSnapshotDirectory"
+  | "nasPartitionAdd"
+  | "nasPartitionDelete"
+  | "nasPartitionUpdate"
+  | "nasQuotaUpdate"
+  | "remoteBackupRecursiveDestroy";
+export const DedicatedStorageTaskFunctionEnum = /*@__PURE__*/ S.String;
+
+/** different task status */
+export type DedicatedTaskStatusEnum =
+  | "cancelled"
+  | "customerError"
+  | "doing"
+  | "done"
+  | "init"
+  | "ovhError"
+  | "todo";
+export const DedicatedTaskStatusEnum = /*@__PURE__*/ S.String;
+
+/** Storage task */
+export interface DedicatedNasTaskTask {
+  /** information about operation */
+  details?: string | null;
+  /** the date when the task finished */
+  doneDate?: string | null;
+  /** last modification of task */
+  lastUpdate?: string | null;
+  /** Task type of operation */
+  operation?: DedicatedStorageTaskFunctionEnum;
+  /** name of the partition */
+  partitionName?: string | null;
+  /** The actual state of the task */
+  status?: DedicatedTaskStatusEnum;
+  /** the name of your service */
+  storageName?: string | null;
+  /** id of the task */
+  taskId?: number;
+  /** Insertion of task in the todo */
+  todoDate?: string | null;
+}
+export const DedicatedNasTaskTask = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    details: S.optional(S.NullOr(S.String)),
+    doneDate: S.optional(S.NullOr(S.String)),
+    lastUpdate: S.optional(S.NullOr(S.String)),
+    operation: S.optional(DedicatedStorageTaskFunctionEnum),
+    partitionName: S.optional(S.NullOr(S.String)),
+    status: S.optional(DedicatedTaskStatusEnum),
+    storageName: S.optional(S.NullOr(S.String)),
+    taskId: S.optional(S.Number),
+    todoDate: S.optional(S.NullOr(S.String)),
+  }),
+).annotate({
+  identifier: "DedicatedNasTaskTask",
+}) as any as S.Schema<DedicatedNasTaskTask>;
+
+/** Acl Type */
+export type DedicatedStorageAclTypeEnum = "readonly" | "readwrite";
+export const DedicatedStorageAclTypeEnum = /*@__PURE__*/ S.String;
+
+export interface CreateDedicatedNashaPartitionAccessRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+  /** ACL description */
+  aclDescription?: string;
+  /** Ip or block to add */
+  ip: string;
+  /** ACL type */
+  type?: DedicatedStorageAclTypeEnum | (string & {});
+}
+export const CreateDedicatedNashaPartitionAccessRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+      aclDescription: S.optional(S.String),
+      ip: S.String,
+      type: S.optional(DedicatedStorageAclTypeEnum),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}/access",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateDedicatedNashaPartitionAccessRequest",
+  }) as any as S.Schema<CreateDedicatedNashaPartitionAccessRequest>;
+
+export interface CreateDedicatedNashaPartitionCustomSnapshotRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+  /** optional expiration date/time, in iso8601 format */
+  expiration?: string;
+  /** the name of the snapshot */
+  name: string;
+}
+export const CreateDedicatedNashaPartitionCustomSnapshotRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+      expiration: S.optional(S.String),
+      name: S.String,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}/customSnapshot",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateDedicatedNashaPartitionCustomSnapshotRequest",
+  }) as any as S.Schema<CreateDedicatedNashaPartitionCustomSnapshotRequest>;
+
+/** Atime values */
+export type DedicatedStorageAtimeEnum = "off" | "on";
+export const DedicatedStorageAtimeEnum = /*@__PURE__*/ S.String;
+
+/** Recordsize values */
+export type DedicatedStorageRecordSizeEnum =
+  | "1048576"
+  | "131072"
+  | "16384"
+  | "32768"
+  | "4096"
+  | "65536"
+  | "8192";
+export const DedicatedStorageRecordSizeEnum = /*@__PURE__*/ S.String;
+
+/** Sync values */
+export type DedicatedStorageSyncEnum = "always" | "disabled" | "standard";
+export const DedicatedStorageSyncEnum = /*@__PURE__*/ S.String;
+
+/** The template enumeration available for your partition. */
+export type DedicatedStorageTemplateUsageOptionsEnum =
+  | "Databases"
+  | "Default"
+  | "File Systems (big files)"
+  | "Virtual machines";
+export const DedicatedStorageTemplateUsageOptionsEnum = /*@__PURE__*/ S.String;
+
+export interface CreateDedicatedNashaPartitionOptionRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+  /** atime setting */
+  atime?: DedicatedStorageAtimeEnum | (string & {});
+  /** ZFS recordsize */
+  recordsize?: DedicatedStorageRecordSizeEnum | (string & {});
+  /** sync setting */
+  sync?: DedicatedStorageSyncEnum | (string & {});
+  /** The name of the usage template to apply for this partition. */
+  templateName?: DedicatedStorageTemplateUsageOptionsEnum | (string & {});
+}
+export const CreateDedicatedNashaPartitionOptionRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+      atime: S.optional(DedicatedStorageAtimeEnum),
+      recordsize: S.optional(DedicatedStorageRecordSizeEnum),
+      sync: S.optional(DedicatedStorageSyncEnum),
+      templateName: S.optional(DedicatedStorageTemplateUsageOptionsEnum),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}/options",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateDedicatedNashaPartitionOptionRequest",
+  }) as any as S.Schema<CreateDedicatedNashaPartitionOptionRequest>;
+
+export interface CreateDedicatedNashaPartitionQuotaRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+  /** the size to set in MB */
+  size: number;
+  /** the uid to set quota on */
+  uid: number;
+}
+export const CreateDedicatedNashaPartitionQuotaRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+      size: S.Number,
+      uid: S.Number,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}/quota",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateDedicatedNashaPartitionQuotaRequest",
+  }) as any as S.Schema<CreateDedicatedNashaPartitionQuotaRequest>;
+
+/** Partition snapshot allowed */
+export type DedicatedStorageSnapshotEnum =
+  | "day-1"
+  | "day-2"
+  | "day-3"
+  | "day-7"
+  | "hour-1"
+  | "hour-6";
+export const DedicatedStorageSnapshotEnum = /*@__PURE__*/ S.String;
+
+export interface CreateDedicatedNashaPartitionSnapshotRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+  /** Snapshot interval to add */
+  snapshotType: DedicatedStorageSnapshotEnum | (string & {});
+}
+export const CreateDedicatedNashaPartitionSnapshotRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+      snapshotType: DedicatedStorageSnapshotEnum,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}/snapshot",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateDedicatedNashaPartitionSnapshotRequest",
+  }) as any as S.Schema<CreateDedicatedNashaPartitionSnapshotRequest>;
+
+export interface DeleteDedicatedNashaPartitionRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+}
+export const DeleteDedicatedNashaPartitionRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "DeleteDedicatedNashaPartitionRequest",
+}) as any as S.Schema<DeleteDedicatedNashaPartitionRequest>;
+
+export interface DeleteDedicatedNashaPartitionAccessRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+  /** the ip in root on storage */
+  ip: string;
+}
+export const DeleteDedicatedNashaPartitionAccessRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+      ip: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}/access/{ip}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "DeleteDedicatedNashaPartitionAccessRequest",
+  }) as any as S.Schema<DeleteDedicatedNashaPartitionAccessRequest>;
+
+export interface DeleteDedicatedNashaPartitionCustomSnapshotRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+  /** name of the snapshot */
+  name: string;
+}
+export const DeleteDedicatedNashaPartitionCustomSnapshotRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+      name: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}/customSnapshot/{name}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "DeleteDedicatedNashaPartitionCustomSnapshotRequest",
+  }) as any as S.Schema<DeleteDedicatedNashaPartitionCustomSnapshotRequest>;
+
+export interface DeleteDedicatedNashaPartitionQuotaRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+  /** the uid to set quota on */
+  uid: number;
+}
+export const DeleteDedicatedNashaPartitionQuotaRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+      uid: S.Number.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}/quota/{uid}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "DeleteDedicatedNashaPartitionQuotaRequest",
+  }) as any as S.Schema<DeleteDedicatedNashaPartitionQuotaRequest>;
+
+/** Partition snapshot allowed */
+export type DeleteDedicatedNashaPartitionSnapshotRequestSnapshotType =
+  | "day-1"
+  | "day-2"
+  | "day-3"
+  | "day-7"
+  | "hour-1"
+  | "hour-6";
+export const DeleteDedicatedNashaPartitionSnapshotRequestSnapshotType =
+  /*@__PURE__*/ S.String;
+
+export interface DeleteDedicatedNashaPartitionSnapshotRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+  /** the interval of snapshot */
+  snapshotType:
+    | DeleteDedicatedNashaPartitionSnapshotRequestSnapshotType
+    | (string & {});
+}
+export const DeleteDedicatedNashaPartitionSnapshotRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+      snapshotType:
+        DeleteDedicatedNashaPartitionSnapshotRequestSnapshotType.pipe(
+          T.Label(),
+        ),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}/snapshot/{snapshotType}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "DeleteDedicatedNashaPartitionSnapshotRequest",
+  }) as any as S.Schema<DeleteDedicatedNashaPartitionSnapshotRequest>;
+
+export interface GetDedicatedNashaRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+}
+export const GetDedicatedNashaRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/dedicated/nasha/{serviceName}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetDedicatedNashaRequest",
+}) as any as S.Schema<GetDedicatedNashaRequest>;
+
+/** the disk type of the nasHa */
+export type DedicatedStorageDiskTypeEnum = "hdd" | "nvme" | "ssd";
+export const DedicatedStorageDiskTypeEnum = /*@__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>;
+
+/** Storage nas HA */
+export interface DedicatedNashaStorageWithIAM {
+  /** True, if partition creation is allowed on this nas HA */
+  canCreatePartition?: boolean;
+  /** The name you give to the nas */
+  customName?: string | null;
+  /** area of nas */
+  datacenter?: string | null;
+  /** the disk type of the nasHa */
+  diskType?: DedicatedStorageDiskTypeEnum;
+  /** IAM resource metadata */
+  iam?: IamResourceMetadata | null;
+  /** Access ip of nas */
+  ip?: string | null;
+  /** Send an email to customer if any issue is detected */
+  monitored?: boolean;
+  /** The storage service name */
+  serviceName?: string;
+  /** percentage of nas space used in % */
+  zpoolCapacity?: number;
+  /** the size of the nas */
+  zpoolSize?: number;
+}
+export const DedicatedNashaStorageWithIAM = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    canCreatePartition: S.optional(S.Boolean),
+    customName: S.optional(S.NullOr(S.String)),
+    datacenter: S.optional(S.NullOr(S.String)),
+    diskType: S.optional(DedicatedStorageDiskTypeEnum),
+    iam: S.optional(S.NullOr(IamResourceMetadata)),
+    ip: S.optional(S.NullOr(S.String)),
+    monitored: S.optional(S.Boolean),
+    serviceName: S.optional(S.String),
+    zpoolCapacity: S.optional(S.Number),
+    zpoolSize: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "DedicatedNashaStorageWithIAM",
+}) as any as S.Schema<DedicatedNashaStorageWithIAM>;
+
+export interface GetDedicatedNashaMetricsTokenRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+}
+export const GetDedicatedNashaMetricsTokenRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/dedicated/nasha/{serviceName}/metricsToken",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetDedicatedNashaMetricsTokenRequest",
+}) as any as S.Schema<GetDedicatedNashaMetricsTokenRequest>;
+
+/** A structure describing the metrics token result */
+export interface DedicatedStorageMetricsTokenResult {
+  /** The url of the endpoint */
+  endpoint?: string;
+  /** The token value */
+  token?: string;
+}
+export const DedicatedStorageMetricsTokenResult = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    endpoint: S.optional(S.String),
+    token: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "DedicatedStorageMetricsTokenResult",
+}) as any as S.Schema<DedicatedStorageMetricsTokenResult>;
+
+export interface GetDedicatedNashaPartitionRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+}
+export const GetDedicatedNashaPartitionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    partitionName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetDedicatedNashaPartitionRequest",
+}) as any as S.Schema<GetDedicatedNashaPartitionRequest>;
+
+/** Storage zpool partition */
+export interface DedicatedNashaPartition {
+  /** percentage of partition space used in % */
+  partitionCapacity?: number | null;
+  /** a brief description of the partition */
+  partitionDescription?: string | null;
+  /** the given name of partition */
+  partitionName?: string;
+  /** must be nfs cifs or both */
+  protocol?: DedicatedStorageProtocolEnum;
+  /** Partition size */
+  size?: number;
+  /** percentage of partition space used by snapshots, in % */
+  usedBySnapshots?: number | null;
+}
+export const DedicatedNashaPartition = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    partitionCapacity: S.optional(S.NullOr(S.Number)),
+    partitionDescription: S.optional(S.NullOr(S.String)),
+    partitionName: S.optional(S.String),
+    protocol: S.optional(DedicatedStorageProtocolEnum),
+    size: S.optional(S.Number),
+    usedBySnapshots: S.optional(S.NullOr(S.Number)),
+  }),
+).annotate({
+  identifier: "DedicatedNashaPartition",
+}) as any as S.Schema<DedicatedNashaPartition>;
+
+export interface GetDedicatedNashaPartitionAccessRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+  /** the ip in root on storage */
+  ip: string;
+}
+export const GetDedicatedNashaPartitionAccessRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+      ip: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}/access/{ip}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetDedicatedNashaPartitionAccessRequest",
+}) as any as S.Schema<GetDedicatedNashaPartitionAccessRequest>;
+
+/** Define Acl for partition */
+export interface DedicatedNashaAccess {
+  /** the id of the access */
+  accessId?: number;
+  /** a brief description of the acl */
+  aclDescription?: string | null;
+  /** the ip in root on storage */
+  ip?: string;
+  /** ACL type */
+  type?: DedicatedStorageAclTypeEnum;
+}
+export const DedicatedNashaAccess = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    accessId: S.optional(S.Number),
+    aclDescription: S.optional(S.NullOr(S.String)),
+    ip: S.optional(S.String),
+    type: S.optional(DedicatedStorageAclTypeEnum),
+  }),
+).annotate({
+  identifier: "DedicatedNashaAccess",
+}) as any as S.Schema<DedicatedNashaAccess>;
+
+export interface GetDedicatedNashaPartitionCustomSnapshotRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+  /** name of the snapshot */
+  name: string;
+}
+export const GetDedicatedNashaPartitionCustomSnapshotRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+      name: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}/customSnapshot/{name}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GetDedicatedNashaPartitionCustomSnapshotRequest",
+  }) as any as S.Schema<GetDedicatedNashaPartitionCustomSnapshotRequest>;
+
+/** Custom Snapshot */
+export interface DedicatedNashaCustomSnap {
+  /** date and time at which snapshot will be automatically destroyed */
+  expiration?: string | null;
+  /** name of the snapshot */
+  name?: string;
+}
+export const DedicatedNashaCustomSnap = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    expiration: S.optional(S.NullOr(S.String)),
+    name: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "DedicatedNashaCustomSnap",
+}) as any as S.Schema<DedicatedNashaCustomSnap>;
+
+export interface GetDedicatedNashaPartitionOptionsRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+}
+export const GetDedicatedNashaPartitionOptionsRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}/options",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetDedicatedNashaPartitionOptionsRequest",
+}) as any as S.Schema<GetDedicatedNashaPartitionOptionsRequest>;
+
+/** Partition options */
+export interface DedicatedNashaOptions {
+  /** atime setting */
+  atime?: string;
+  /** ID */
+  id?: number;
+  /** ZFS recordsize */
+  recordsize?: string;
+  /** sync setting */
+  sync?: string;
+  /** the template name */
+  templateName?: DedicatedStorageTemplateUsageOptionsEnum | null;
+}
+export const DedicatedNashaOptions = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    atime: S.optional(S.String),
+    id: S.optional(S.Number),
+    recordsize: S.optional(S.String),
+    sync: S.optional(S.String),
+    templateName: S.optional(
+      S.NullOr(DedicatedStorageTemplateUsageOptionsEnum),
+    ),
+  }),
+).annotate({
+  identifier: "DedicatedNashaOptions",
+}) as any as S.Schema<DedicatedNashaOptions>;
+
+export interface GetDedicatedNashaPartitionQuotaRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+  /** the uid to set quota on */
+  uid: number;
+}
+export const GetDedicatedNashaPartitionQuotaRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+      uid: S.Number.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}/quota/{uid}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetDedicatedNashaPartitionQuotaRequest",
+}) as any as S.Schema<GetDedicatedNashaPartitionQuotaRequest>;
+
+/** Partition Quota */
+export interface DedicatedNashaQuota {
+  /** the size to set in MB */
+  size?: number;
+  /** the uid to set quota on */
+  uid?: number;
+}
+export const DedicatedNashaQuota = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    size: S.optional(S.Number),
+    uid: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "DedicatedNashaQuota",
+}) as any as S.Schema<DedicatedNashaQuota>;
+
+/** Partition snapshot allowed */
+export type GetDedicatedNashaPartitionSnapshotRequestSnapshotType =
+  | "day-1"
+  | "day-2"
+  | "day-3"
+  | "day-7"
+  | "hour-1"
+  | "hour-6";
+export const GetDedicatedNashaPartitionSnapshotRequestSnapshotType =
+  /*@__PURE__*/ S.String;
+
+export interface GetDedicatedNashaPartitionSnapshotRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+  /** the interval of snapshot */
+  snapshotType:
+    | GetDedicatedNashaPartitionSnapshotRequestSnapshotType
+    | (string & {});
+}
+export const GetDedicatedNashaPartitionSnapshotRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+      snapshotType: GetDedicatedNashaPartitionSnapshotRequestSnapshotType.pipe(
+        T.Label(),
+      ),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}/snapshot/{snapshotType}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GetDedicatedNashaPartitionSnapshotRequest",
+  }) as any as S.Schema<GetDedicatedNashaPartitionSnapshotRequest>;
+
+/** Partition Snapshot */
+export interface DedicatedNashaSnapshot {
+  /** the interval of snapshot */
+  snapshotType?: DedicatedStorageSnapshotEnum;
+}
+export const DedicatedNashaSnapshot = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    snapshotType: S.optional(DedicatedStorageSnapshotEnum),
+  }),
+).annotate({
+  identifier: "DedicatedNashaSnapshot",
+}) as any as S.Schema<DedicatedNashaSnapshot>;
+
+/** Available types for NAS partition usage */
+export type DedicatedStoragePartitionUsageTypeEnum =
+  | "size"
+  | "used"
+  | "usedbysnapshots";
+export const DedicatedStoragePartitionUsageTypeEnum = /*@__PURE__*/ S.String;
+
+export interface GetDedicatedNashaPartitionUseRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+  /** The type of statistic to be fetched */
+  type: DedicatedStoragePartitionUsageTypeEnum | (string & {});
+}
+export const GetDedicatedNashaPartitionUseRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+      type: DedicatedStoragePartitionUsageTypeEnum.pipe(T.Query()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}/use",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetDedicatedNashaPartitionUseRequest",
+}) as any as S.Schema<GetDedicatedNashaPartitionUseRequest>;
+
+/** A numeric value tagged with its unit */
+export interface ComplexTypeUnitAndValueDouble {
+  unit?: string;
+  value?: number;
+}
+export const ComplexTypeUnitAndValueDouble = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    unit: S.optional(S.String),
+    value: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "ComplexTypeUnitAndValueDouble",
+}) as any as S.Schema<ComplexTypeUnitAndValueDouble>;
+
+export interface GetDedicatedNashaServiceInfosRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+}
+export const GetDedicatedNashaServiceInfosRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/dedicated/nasha/{serviceName}/serviceInfos",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetDedicatedNashaServiceInfosRequest",
+}) as any as S.Schema<GetDedicatedNashaServiceInfosRequest>;
+
+/** 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"
+  | "automaticV2024"
+  | "manual"
+  | "oneShot"
+  | "option";
+export const ServiceRenewalTypeEnum = /*@__PURE__*/ S.String;
+
+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 GetDedicatedNashaTaskRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** id of the task */
+  taskId: number;
+}
+export const GetDedicatedNashaTaskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    taskId: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/dedicated/nasha/{serviceName}/task/{taskId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetDedicatedNashaTaskRequest",
+}) as any as S.Schema<GetDedicatedNashaTaskRequest>;
+
+/** Available types for NAS usage */
+export type DedicatedStorageNasUsageTypeEnum =
+  | "size"
+  | "used"
+  | "usedbysnapshots";
+export const DedicatedStorageNasUsageTypeEnum = /*@__PURE__*/ S.String;
+
+export interface GetDedicatedNashaUseRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** The type of statistic to be fetched */
+  type: DedicatedStorageNasUsageTypeEnum | (string & {});
+}
+export const GetDedicatedNashaUseRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    type: DedicatedStorageNasUsageTypeEnum.pipe(T.Query()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/dedicated/nasha/{serviceName}/use",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetDedicatedNashaUseRequest",
+}) as any as S.Schema<GetDedicatedNashaUseRequest>;
+
+/** 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 ListDedicatedNashaRequestIamTagsValueList =
+  Array<IamResourceTagFilterInput>;
+export const ListDedicatedNashaRequestIamTagsValueList = /*@__PURE__*/ S.Array(
+  IamResourceTagFilterInput,
+) as any as S.Schema<ListDedicatedNashaRequestIamTagsValueList>;
+
+export type ListDedicatedNashaRequestIamTagsMap = {
+  [key: string]: ListDedicatedNashaRequestIamTagsValueList | undefined;
+};
+export const ListDedicatedNashaRequestIamTagsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  ListDedicatedNashaRequestIamTagsValueList,
+) as any as S.Schema<ListDedicatedNashaRequestIamTagsMap>;
+
+export interface ListDedicatedNashaRequest {
+  /** Filter resources on IAM tags */
+  iamTags?: ListDedicatedNashaRequestIamTagsMap;
+}
+export const ListDedicatedNashaRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    iamTags: S.optional(ListDedicatedNashaRequestIamTagsMap.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/dedicated/nasha", code: 200 })),
+).annotate({
+  identifier: "ListDedicatedNashaRequest",
+}) as any as S.Schema<ListDedicatedNashaRequest>;
+
+export type ListDedicatedNashaResponseBodyList = Array<string>;
+export const ListDedicatedNashaResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListDedicatedNashaResponseBodyList>;
+
+export type ListDedicatedNashaResponse = ListDedicatedNashaResponseBodyList;
+export const ListDedicatedNashaResponse = /*@__PURE__*/ S.suspend(() =>
+  ListDedicatedNashaResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListDedicatedNashaResponse",
+}) as any as S.Schema<ListDedicatedNashaResponse>;
+
+export interface ListDedicatedNashaPartitionRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+}
+export const ListDedicatedNashaPartitionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/dedicated/nasha/{serviceName}/partition",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListDedicatedNashaPartitionRequest",
+}) as any as S.Schema<ListDedicatedNashaPartitionRequest>;
+
+export type ListDedicatedNashaPartitionResponseBodyList = Array<string>;
+export const ListDedicatedNashaPartitionResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListDedicatedNashaPartitionResponseBodyList>;
+
+export type ListDedicatedNashaPartitionResponse =
+  ListDedicatedNashaPartitionResponseBodyList;
+export const ListDedicatedNashaPartitionResponse = /*@__PURE__*/ S.suspend(() =>
+  ListDedicatedNashaPartitionResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListDedicatedNashaPartitionResponse",
+}) as any as S.Schema<ListDedicatedNashaPartitionResponse>;
+
+export interface ListDedicatedNashaPartitionAccessRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+}
+export const ListDedicatedNashaPartitionAccessRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}/access",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListDedicatedNashaPartitionAccessRequest",
+}) as any as S.Schema<ListDedicatedNashaPartitionAccessRequest>;
+
+export type ListDedicatedNashaPartitionAccessResponseBodyList = Array<string>;
+export const ListDedicatedNashaPartitionAccessResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListDedicatedNashaPartitionAccessResponseBodyList>;
+
+export type ListDedicatedNashaPartitionAccessResponse =
+  ListDedicatedNashaPartitionAccessResponseBodyList;
+export const ListDedicatedNashaPartitionAccessResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListDedicatedNashaPartitionAccessResponseBodyList.pipe(T.RawResponseRoot()),
+  ).annotate({
+    identifier: "ListDedicatedNashaPartitionAccessResponse",
+  }) as any as S.Schema<ListDedicatedNashaPartitionAccessResponse>;
+
+export interface ListDedicatedNashaPartitionAuthorizableBlocksRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+}
+export const ListDedicatedNashaPartitionAuthorizableBlocksRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}/authorizableBlocks",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListDedicatedNashaPartitionAuthorizableBlocksRequest",
+  }) as any as S.Schema<ListDedicatedNashaPartitionAuthorizableBlocksRequest>;
+
+export type ListDedicatedNashaPartitionAuthorizableBlocksResponseBodyList =
+  Array<string>;
+export const ListDedicatedNashaPartitionAuthorizableBlocksResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListDedicatedNashaPartitionAuthorizableBlocksResponseBodyList>;
+
+export type ListDedicatedNashaPartitionAuthorizableBlocksResponse =
+  ListDedicatedNashaPartitionAuthorizableBlocksResponseBodyList;
+export const ListDedicatedNashaPartitionAuthorizableBlocksResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListDedicatedNashaPartitionAuthorizableBlocksResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListDedicatedNashaPartitionAuthorizableBlocksResponse",
+  }) as any as S.Schema<ListDedicatedNashaPartitionAuthorizableBlocksResponse>;
+
+export interface ListDedicatedNashaPartitionAuthorizableIpsRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+}
+export const ListDedicatedNashaPartitionAuthorizableIpsRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}/authorizableIps",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListDedicatedNashaPartitionAuthorizableIpsRequest",
+  }) as any as S.Schema<ListDedicatedNashaPartitionAuthorizableIpsRequest>;
+
+export type ListDedicatedNashaPartitionAuthorizableIpsResponseBodyList =
+  Array<string>;
+export const ListDedicatedNashaPartitionAuthorizableIpsResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListDedicatedNashaPartitionAuthorizableIpsResponseBodyList>;
+
+export type ListDedicatedNashaPartitionAuthorizableIpsResponse =
+  ListDedicatedNashaPartitionAuthorizableIpsResponseBodyList;
+export const ListDedicatedNashaPartitionAuthorizableIpsResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListDedicatedNashaPartitionAuthorizableIpsResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListDedicatedNashaPartitionAuthorizableIpsResponse",
+  }) as any as S.Schema<ListDedicatedNashaPartitionAuthorizableIpsResponse>;
+
+export interface ListDedicatedNashaPartitionCustomSnapshotRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+}
+export const ListDedicatedNashaPartitionCustomSnapshotRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}/customSnapshot",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListDedicatedNashaPartitionCustomSnapshotRequest",
+  }) as any as S.Schema<ListDedicatedNashaPartitionCustomSnapshotRequest>;
+
+export type ListDedicatedNashaPartitionCustomSnapshotResponseBodyList =
+  Array<string>;
+export const ListDedicatedNashaPartitionCustomSnapshotResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListDedicatedNashaPartitionCustomSnapshotResponseBodyList>;
+
+export type ListDedicatedNashaPartitionCustomSnapshotResponse =
+  ListDedicatedNashaPartitionCustomSnapshotResponseBodyList;
+export const ListDedicatedNashaPartitionCustomSnapshotResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListDedicatedNashaPartitionCustomSnapshotResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListDedicatedNashaPartitionCustomSnapshotResponse",
+  }) as any as S.Schema<ListDedicatedNashaPartitionCustomSnapshotResponse>;
+
+export interface ListDedicatedNashaPartitionQuotaRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+}
+export const ListDedicatedNashaPartitionQuotaRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}/quota",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListDedicatedNashaPartitionQuotaRequest",
+}) as any as S.Schema<ListDedicatedNashaPartitionQuotaRequest>;
+
+export type ListDedicatedNashaPartitionQuotaResponseBodyList = Array<number>;
+export const ListDedicatedNashaPartitionQuotaResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.Number,
+  ) as any as S.Schema<ListDedicatedNashaPartitionQuotaResponseBodyList>;
+
+export type ListDedicatedNashaPartitionQuotaResponse =
+  ListDedicatedNashaPartitionQuotaResponseBodyList;
+export const ListDedicatedNashaPartitionQuotaResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    ListDedicatedNashaPartitionQuotaResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListDedicatedNashaPartitionQuotaResponse",
+}) as any as S.Schema<ListDedicatedNashaPartitionQuotaResponse>;
+
+export interface ListDedicatedNashaPartitionSnapshotRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+}
+export const ListDedicatedNashaPartitionSnapshotRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}/snapshot",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListDedicatedNashaPartitionSnapshotRequest",
+  }) as any as S.Schema<ListDedicatedNashaPartitionSnapshotRequest>;
+
+export type ListDedicatedNashaPartitionSnapshotResponseBodyList =
+  Array<DedicatedStorageSnapshotEnum>;
+export const ListDedicatedNashaPartitionSnapshotResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    DedicatedStorageSnapshotEnum,
+  ) as any as S.Schema<ListDedicatedNashaPartitionSnapshotResponseBodyList>;
+
+export type ListDedicatedNashaPartitionSnapshotResponse =
+  ListDedicatedNashaPartitionSnapshotResponseBodyList;
+export const ListDedicatedNashaPartitionSnapshotResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListDedicatedNashaPartitionSnapshotResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListDedicatedNashaPartitionSnapshotResponse",
+  }) as any as S.Schema<ListDedicatedNashaPartitionSnapshotResponse>;
+
+export interface ListDedicatedNashaPartitionTemplateUsageRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+}
+export const ListDedicatedNashaPartitionTemplateUsageRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      partitionName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}/templateUsage",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListDedicatedNashaPartitionTemplateUsageRequest",
+  }) as any as S.Schema<ListDedicatedNashaPartitionTemplateUsageRequest>;
+
+/** A structure describing the template usage result */
+export interface DedicatedStorageTemplateUsageOptionsDetails {
+  /** The description of the template. */
+  description?: string;
+  /** The name of the template */
+  name?: string;
+}
+export const DedicatedStorageTemplateUsageOptionsDetails =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      description: S.optional(S.String),
+      name: S.optional(S.String),
+    }),
+  ).annotate({
+    identifier: "DedicatedStorageTemplateUsageOptionsDetails",
+  }) as any as S.Schema<DedicatedStorageTemplateUsageOptionsDetails>;
+
+export type ListDedicatedNashaPartitionTemplateUsageResponseBodyList =
+  Array<DedicatedStorageTemplateUsageOptionsDetails>;
+export const ListDedicatedNashaPartitionTemplateUsageResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    DedicatedStorageTemplateUsageOptionsDetails,
+  ) as any as S.Schema<ListDedicatedNashaPartitionTemplateUsageResponseBodyList>;
+
+export type ListDedicatedNashaPartitionTemplateUsageResponse =
+  ListDedicatedNashaPartitionTemplateUsageResponseBodyList;
+export const ListDedicatedNashaPartitionTemplateUsageResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListDedicatedNashaPartitionTemplateUsageResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListDedicatedNashaPartitionTemplateUsageResponse",
+  }) as any as S.Schema<ListDedicatedNashaPartitionTemplateUsageResponse>;
+
+export interface ListDedicatedNashaTaskRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** Filter the value of operation property (=) */
+  operation?: DedicatedStorageTaskFunctionEnum | (string & {});
+  /** Filter the value of status property (=) */
+  status?: DedicatedTaskStatusEnum | (string & {});
+}
+export const ListDedicatedNashaTaskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    operation: S.optional(DedicatedStorageTaskFunctionEnum.pipe(T.Query())),
+    status: S.optional(DedicatedTaskStatusEnum.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/dedicated/nasha/{serviceName}/task",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListDedicatedNashaTaskRequest",
+}) as any as S.Schema<ListDedicatedNashaTaskRequest>;
+
+export type ListDedicatedNashaTaskResponseBodyList = Array<number>;
+export const ListDedicatedNashaTaskResponseBodyList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<ListDedicatedNashaTaskResponseBodyList>;
+
+export type ListDedicatedNashaTaskResponse =
+  ListDedicatedNashaTaskResponseBodyList;
+export const ListDedicatedNashaTaskResponse = /*@__PURE__*/ S.suspend(() =>
+  ListDedicatedNashaTaskResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListDedicatedNashaTaskResponse",
+}) as any as S.Schema<ListDedicatedNashaTaskResponse>;
+
+export interface PutDedicatedNashaRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** The name you give to the nas */
+  customName?: string | null;
+  /** Send an email to customer if any issue is detected */
+  monitored?: boolean;
+}
+export const PutDedicatedNashaRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    customName: S.optional(S.NullOr(S.String)),
+    monitored: S.optional(S.Boolean),
+  }).pipe(
+    T.Http({ method: "PUT", uri: "/dedicated/nasha/{serviceName}", code: 200 }),
+  ),
+).annotate({
+  identifier: "PutDedicatedNashaRequest",
+}) as any as S.Schema<PutDedicatedNashaRequest>;
+
+export interface PutDedicatedNashaResponse {}
+export const PutDedicatedNashaResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutDedicatedNashaResponse",
+}) as any as S.Schema<PutDedicatedNashaResponse>;
+
+export interface PutDedicatedNashaPartitionRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** the given name of partition */
+  partitionName: string;
+  /** a brief description of the partition */
+  partitionDescription?: string | null;
+  /** Partition size */
+  size?: number;
+}
+export const PutDedicatedNashaPartitionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    partitionName: S.String.pipe(T.Label()),
+    partitionDescription: S.optional(S.NullOr(S.String)),
+    size: S.optional(S.Number),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/dedicated/nasha/{serviceName}/partition/{partitionName}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutDedicatedNashaPartitionRequest",
+}) as any as S.Schema<PutDedicatedNashaPartitionRequest>;
+
+export interface PutDedicatedNashaPartitionResponse {}
+export const PutDedicatedNashaPartitionResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutDedicatedNashaPartitionResponse",
+}) as any as S.Schema<PutDedicatedNashaPartitionResponse>;
+
+export interface PutDedicatedNashaServiceInfosRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+  /** Way of handling the renew */
+  renew?: ServiceRenewType | null;
+}
+export const PutDedicatedNashaServiceInfosRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      renew: S.optional(S.NullOr(ServiceRenewType)),
+    }).pipe(
+      T.Http({
+        method: "PUT",
+        uri: "/dedicated/nasha/{serviceName}/serviceInfos",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "PutDedicatedNashaServiceInfosRequest",
+}) as any as S.Schema<PutDedicatedNashaServiceInfosRequest>;
+
+export interface PutDedicatedNashaServiceInfosResponse {}
+export const PutDedicatedNashaServiceInfosResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "PutDedicatedNashaServiceInfosResponse",
+}) as any as S.Schema<PutDedicatedNashaServiceInfosResponse>;
+
+export interface TerminateDedicatedNashaRequest {
+  /** The internal name of your storage */
+  serviceName: string;
+}
+export const TerminateDedicatedNashaRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/dedicated/nasha/{serviceName}/terminate",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "TerminateDedicatedNashaRequest",
+}) as any as S.Schema<TerminateDedicatedNashaRequest>;
+
+export type TerminateDedicatedNashaResponse = string;
+export const TerminateDedicatedNashaResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "TerminateDedicatedNashaResponse",
+}) as any as S.Schema<TerminateDedicatedNashaResponse>;
+
+export type ConfirmDedicatedNashaTerminationError = OvhOpError;
+/** Confirm service termination */
+export const confirmDedicatedNashaTermination: API.OperationMethod<
+  ConfirmDedicatedNashaTerminationRequest,
+  ConfirmDedicatedNashaTerminationResponse,
+  ConfirmDedicatedNashaTerminationError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ConfirmDedicatedNashaTerminationRequest,
+  output: ConfirmDedicatedNashaTerminationResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateDedicatedNashaChangeContactError = OvhOpError;
+/** Launch a contact change procedure */
+export const createDedicatedNashaChangeContact: API.OperationMethod<
+  CreateDedicatedNashaChangeContactRequest,
+  CreateDedicatedNashaChangeContactResponse,
+  CreateDedicatedNashaChangeContactError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateDedicatedNashaChangeContactRequest,
+  output: CreateDedicatedNashaChangeContactResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateDedicatedNashaPartitionError = OvhOpError;
+/** Create a new partition */
+export const createDedicatedNashaPartition: API.OperationMethod<
+  CreateDedicatedNashaPartitionRequest,
+  DedicatedNasTaskTask,
+  CreateDedicatedNashaPartitionError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateDedicatedNashaPartitionRequest,
+  output: DedicatedNasTaskTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateDedicatedNashaPartitionAccessError = OvhOpError;
+/** Add a new ACL entry */
+export const createDedicatedNashaPartitionAccess: API.OperationMethod<
+  CreateDedicatedNashaPartitionAccessRequest,
+  DedicatedNasTaskTask,
+  CreateDedicatedNashaPartitionAccessError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateDedicatedNashaPartitionAccessRequest,
+  output: DedicatedNasTaskTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateDedicatedNashaPartitionCustomSnapshotError = OvhOpError;
+/** Create a new snapshot */
+export const createDedicatedNashaPartitionCustomSnapshot: API.OperationMethod<
+  CreateDedicatedNashaPartitionCustomSnapshotRequest,
+  DedicatedNasTaskTask,
+  CreateDedicatedNashaPartitionCustomSnapshotError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateDedicatedNashaPartitionCustomSnapshotRequest,
+  output: DedicatedNasTaskTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateDedicatedNashaPartitionOptionError = OvhOpError;
+/** Setup options */
+export const createDedicatedNashaPartitionOption: API.OperationMethod<
+  CreateDedicatedNashaPartitionOptionRequest,
+  DedicatedNasTaskTask,
+  CreateDedicatedNashaPartitionOptionError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateDedicatedNashaPartitionOptionRequest,
+  output: DedicatedNasTaskTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateDedicatedNashaPartitionQuotaError = OvhOpError;
+/** Set a new quota */
+export const createDedicatedNashaPartitionQuota: API.OperationMethod<
+  CreateDedicatedNashaPartitionQuotaRequest,
+  DedicatedNasTaskTask,
+  CreateDedicatedNashaPartitionQuotaError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateDedicatedNashaPartitionQuotaRequest,
+  output: DedicatedNasTaskTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateDedicatedNashaPartitionSnapshotError = OvhOpError;
+/** Schedule a new snapshot type */
+export const createDedicatedNashaPartitionSnapshot: API.OperationMethod<
+  CreateDedicatedNashaPartitionSnapshotRequest,
+  DedicatedNasTaskTask,
+  CreateDedicatedNashaPartitionSnapshotError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateDedicatedNashaPartitionSnapshotRequest,
+  output: DedicatedNasTaskTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteDedicatedNashaPartitionError = OvhOpError;
+/** Delete this partition */
+export const deleteDedicatedNashaPartition: API.OperationMethod<
+  DeleteDedicatedNashaPartitionRequest,
+  DedicatedNasTaskTask,
+  DeleteDedicatedNashaPartitionError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteDedicatedNashaPartitionRequest,
+  output: DedicatedNasTaskTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteDedicatedNashaPartitionAccessError = OvhOpError;
+/** Delete an ACL entry */
+export const deleteDedicatedNashaPartitionAccess: API.OperationMethod<
+  DeleteDedicatedNashaPartitionAccessRequest,
+  DedicatedNasTaskTask,
+  DeleteDedicatedNashaPartitionAccessError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteDedicatedNashaPartitionAccessRequest,
+  output: DedicatedNasTaskTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteDedicatedNashaPartitionCustomSnapshotError = OvhOpError;
+/** Delete a given snapshot */
+export const deleteDedicatedNashaPartitionCustomSnapshot: API.OperationMethod<
+  DeleteDedicatedNashaPartitionCustomSnapshotRequest,
+  DedicatedNasTaskTask,
+  DeleteDedicatedNashaPartitionCustomSnapshotError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteDedicatedNashaPartitionCustomSnapshotRequest,
+  output: DedicatedNasTaskTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteDedicatedNashaPartitionQuotaError = OvhOpError;
+/** Delete a given quota */
+export const deleteDedicatedNashaPartitionQuota: API.OperationMethod<
+  DeleteDedicatedNashaPartitionQuotaRequest,
+  DedicatedNasTaskTask,
+  DeleteDedicatedNashaPartitionQuotaError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteDedicatedNashaPartitionQuotaRequest,
+  output: DedicatedNasTaskTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteDedicatedNashaPartitionSnapshotError = OvhOpError;
+/** Delete a given snapshot */
+export const deleteDedicatedNashaPartitionSnapshot: API.OperationMethod<
+  DeleteDedicatedNashaPartitionSnapshotRequest,
+  DedicatedNasTaskTask,
+  DeleteDedicatedNashaPartitionSnapshotError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteDedicatedNashaPartitionSnapshotRequest,
+  output: DedicatedNasTaskTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetDedicatedNashaError = OvhOpError;
+/** Get this object properties */
+export const getDedicatedNasha: API.OperationMethod<
+  GetDedicatedNashaRequest,
+  DedicatedNashaStorageWithIAM,
+  GetDedicatedNashaError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetDedicatedNashaRequest,
+  output: DedicatedNashaStorageWithIAM,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetDedicatedNashaMetricsTokenError = OvhOpError;
+/** Return a read token for manager mimir metrics */
+export const getDedicatedNashaMetricsToken: API.OperationMethod<
+  GetDedicatedNashaMetricsTokenRequest,
+  DedicatedStorageMetricsTokenResult,
+  GetDedicatedNashaMetricsTokenError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetDedicatedNashaMetricsTokenRequest,
+  output: DedicatedStorageMetricsTokenResult,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetDedicatedNashaPartitionError = OvhOpError;
+/** Get this object properties */
+export const getDedicatedNashaPartition: API.OperationMethod<
+  GetDedicatedNashaPartitionRequest,
+  DedicatedNashaPartition,
+  GetDedicatedNashaPartitionError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetDedicatedNashaPartitionRequest,
+  output: DedicatedNashaPartition,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetDedicatedNashaPartitionAccessError = OvhOpError;
+/** Get this object properties */
+export const getDedicatedNashaPartitionAccess: API.OperationMethod<
+  GetDedicatedNashaPartitionAccessRequest,
+  DedicatedNashaAccess,
+  GetDedicatedNashaPartitionAccessError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetDedicatedNashaPartitionAccessRequest,
+  output: DedicatedNashaAccess,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetDedicatedNashaPartitionCustomSnapshotError = OvhOpError;
+/** Get this object properties */
+export const getDedicatedNashaPartitionCustomSnapshot: API.OperationMethod<
+  GetDedicatedNashaPartitionCustomSnapshotRequest,
+  DedicatedNashaCustomSnap,
+  GetDedicatedNashaPartitionCustomSnapshotError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetDedicatedNashaPartitionCustomSnapshotRequest,
+  output: DedicatedNashaCustomSnap,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetDedicatedNashaPartitionOptionsError = OvhOpError;
+/** Get this object properties */
+export const getDedicatedNashaPartitionOptions: API.OperationMethod<
+  GetDedicatedNashaPartitionOptionsRequest,
+  DedicatedNashaOptions,
+  GetDedicatedNashaPartitionOptionsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetDedicatedNashaPartitionOptionsRequest,
+  output: DedicatedNashaOptions,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetDedicatedNashaPartitionQuotaError = OvhOpError;
+/** Get this object properties */
+export const getDedicatedNashaPartitionQuota: API.OperationMethod<
+  GetDedicatedNashaPartitionQuotaRequest,
+  DedicatedNashaQuota,
+  GetDedicatedNashaPartitionQuotaError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetDedicatedNashaPartitionQuotaRequest,
+  output: DedicatedNashaQuota,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetDedicatedNashaPartitionSnapshotError = OvhOpError;
+/** Get this object properties */
+export const getDedicatedNashaPartitionSnapshot: API.OperationMethod<
+  GetDedicatedNashaPartitionSnapshotRequest,
+  DedicatedNashaSnapshot,
+  GetDedicatedNashaPartitionSnapshotError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetDedicatedNashaPartitionSnapshotRequest,
+  output: DedicatedNashaSnapshot,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetDedicatedNashaPartitionUseError = OvhOpError;
+/** Return statistics about the partition */
+export const getDedicatedNashaPartitionUse: API.OperationMethod<
+  GetDedicatedNashaPartitionUseRequest,
+  ComplexTypeUnitAndValueDouble,
+  GetDedicatedNashaPartitionUseError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetDedicatedNashaPartitionUseRequest,
+  output: ComplexTypeUnitAndValueDouble,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetDedicatedNashaServiceInfosError = OvhOpError;
+/** Get service information */
+export const getDedicatedNashaServiceInfos: API.OperationMethod<
+  GetDedicatedNashaServiceInfosRequest,
+  ServicesService,
+  GetDedicatedNashaServiceInfosError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetDedicatedNashaServiceInfosRequest,
+  output: ServicesService,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetDedicatedNashaTaskError = OvhOpError;
+/** Get this object properties */
+export const getDedicatedNashaTask: API.OperationMethod<
+  GetDedicatedNashaTaskRequest,
+  DedicatedNasTaskTask,
+  GetDedicatedNashaTaskError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetDedicatedNashaTaskRequest,
+  output: DedicatedNasTaskTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetDedicatedNashaUseError = OvhOpError;
+/** Return statistics about the nas */
+export const getDedicatedNashaUse: API.OperationMethod<
+  GetDedicatedNashaUseRequest,
+  ComplexTypeUnitAndValueDouble,
+  GetDedicatedNashaUseError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetDedicatedNashaUseRequest,
+  output: ComplexTypeUnitAndValueDouble,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListDedicatedNashaError = OvhOpError;
+/** List available services */
+export const listDedicatedNasha: API.OperationMethod<
+  ListDedicatedNashaRequest,
+  ListDedicatedNashaResponse,
+  ListDedicatedNashaError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListDedicatedNashaRequest,
+  output: ListDedicatedNashaResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListDedicatedNashaPartitionError = OvhOpError;
+/** Get partition list */
+export const listDedicatedNashaPartition: API.OperationMethod<
+  ListDedicatedNashaPartitionRequest,
+  ListDedicatedNashaPartitionResponse,
+  ListDedicatedNashaPartitionError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListDedicatedNashaPartitionRequest,
+  output: ListDedicatedNashaPartitionResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListDedicatedNashaPartitionAccessError = OvhOpError;
+/** get ACL for this partition */
+export const listDedicatedNashaPartitionAccess: API.OperationMethod<
+  ListDedicatedNashaPartitionAccessRequest,
+  ListDedicatedNashaPartitionAccessResponse,
+  ListDedicatedNashaPartitionAccessError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListDedicatedNashaPartitionAccessRequest,
+  output: ListDedicatedNashaPartitionAccessResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListDedicatedNashaPartitionAuthorizableBlocksError = OvhOpError;
+/** Get all RIPE/ARIN blocks that can be used in the ACL */
+export const listDedicatedNashaPartitionAuthorizableBlocks: API.OperationMethod<
+  ListDedicatedNashaPartitionAuthorizableBlocksRequest,
+  ListDedicatedNashaPartitionAuthorizableBlocksResponse,
+  ListDedicatedNashaPartitionAuthorizableBlocksError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListDedicatedNashaPartitionAuthorizableBlocksRequest,
+  output: ListDedicatedNashaPartitionAuthorizableBlocksResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListDedicatedNashaPartitionAuthorizableIpsError = OvhOpError;
+/** Get all IPs that can be used in the ACL */
+export const listDedicatedNashaPartitionAuthorizableIps: API.OperationMethod<
+  ListDedicatedNashaPartitionAuthorizableIpsRequest,
+  ListDedicatedNashaPartitionAuthorizableIpsResponse,
+  ListDedicatedNashaPartitionAuthorizableIpsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListDedicatedNashaPartitionAuthorizableIpsRequest,
+  output: ListDedicatedNashaPartitionAuthorizableIpsResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListDedicatedNashaPartitionCustomSnapshotError = OvhOpError;
+/** Get custom snapshots for this partition */
+export const listDedicatedNashaPartitionCustomSnapshot: API.OperationMethod<
+  ListDedicatedNashaPartitionCustomSnapshotRequest,
+  ListDedicatedNashaPartitionCustomSnapshotResponse,
+  ListDedicatedNashaPartitionCustomSnapshotError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListDedicatedNashaPartitionCustomSnapshotRequest,
+  output: ListDedicatedNashaPartitionCustomSnapshotResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListDedicatedNashaPartitionQuotaError = OvhOpError;
+/** Get quota for this partition */
+export const listDedicatedNashaPartitionQuota: API.OperationMethod<
+  ListDedicatedNashaPartitionQuotaRequest,
+  ListDedicatedNashaPartitionQuotaResponse,
+  ListDedicatedNashaPartitionQuotaError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListDedicatedNashaPartitionQuotaRequest,
+  output: ListDedicatedNashaPartitionQuotaResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListDedicatedNashaPartitionSnapshotError = OvhOpError;
+/** Get scheduled snapshot types for this partition */
+export const listDedicatedNashaPartitionSnapshot: API.OperationMethod<
+  ListDedicatedNashaPartitionSnapshotRequest,
+  ListDedicatedNashaPartitionSnapshotResponse,
+  ListDedicatedNashaPartitionSnapshotError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListDedicatedNashaPartitionSnapshotRequest,
+  output: ListDedicatedNashaPartitionSnapshotResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListDedicatedNashaPartitionTemplateUsageError = OvhOpError;
+/** Get all the template usages options applicable to this partition. */
+export const listDedicatedNashaPartitionTemplateUsage: API.OperationMethod<
+  ListDedicatedNashaPartitionTemplateUsageRequest,
+  ListDedicatedNashaPartitionTemplateUsageResponse,
+  ListDedicatedNashaPartitionTemplateUsageError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListDedicatedNashaPartitionTemplateUsageRequest,
+  output: ListDedicatedNashaPartitionTemplateUsageResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListDedicatedNashaTaskError = OvhOpError;
+/** View task list */
+export const listDedicatedNashaTask: API.OperationMethod<
+  ListDedicatedNashaTaskRequest,
+  ListDedicatedNashaTaskResponse,
+  ListDedicatedNashaTaskError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListDedicatedNashaTaskRequest,
+  output: ListDedicatedNashaTaskResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutDedicatedNashaError = OvhOpError;
+/** Alter this object properties */
+export const putDedicatedNasha: API.OperationMethod<
+  PutDedicatedNashaRequest,
+  PutDedicatedNashaResponse,
+  PutDedicatedNashaError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutDedicatedNashaRequest,
+  output: PutDedicatedNashaResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutDedicatedNashaPartitionError = OvhOpError;
+/** Alter this object properties */
+export const putDedicatedNashaPartition: API.OperationMethod<
+  PutDedicatedNashaPartitionRequest,
+  PutDedicatedNashaPartitionResponse,
+  PutDedicatedNashaPartitionError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutDedicatedNashaPartitionRequest,
+  output: PutDedicatedNashaPartitionResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutDedicatedNashaServiceInfosError = OvhOpError;
+/** Update service information */
+export const putDedicatedNashaServiceInfos: API.OperationMethod<
+  PutDedicatedNashaServiceInfosRequest,
+  PutDedicatedNashaServiceInfosResponse,
+  PutDedicatedNashaServiceInfosError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutDedicatedNashaServiceInfosRequest,
+  output: PutDedicatedNashaServiceInfosResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type TerminateDedicatedNashaError = OvhOpError;
+/** Ask for the termination of your service Ask for the termination of your service. Admin contact of this service will receive a termination token by email in order to confirm its termination with /confirmTermination endpoint. */
+export const terminateDedicatedNasha: API.OperationMethod<
+  TerminateDedicatedNashaRequest,
+  TerminateDedicatedNashaResponse,
+  TerminateDedicatedNashaError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: TerminateDedicatedNashaRequest,
+  output: TerminateDedicatedNashaResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));