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

package/src/services/overthebox.ts

@@ -0,0 +1,2693 @@
+// 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 };
+
+export interface AuthorizeOverTheBoxRemoteAccessRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+  /** The id of the remote access */
+  remoteAccessId: string;
+}
+export const AuthorizeOverTheBoxRemoteAccessRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      remoteAccessId: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/overTheBox/{serviceName}/remoteAccesses/{remoteAccessId}/authorize",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "AuthorizeOverTheBoxRemoteAccessRequest",
+}) as any as S.Schema<AuthorizeOverTheBoxRemoteAccessRequest>;
+
+export interface AuthorizeOverTheBoxRemoteAccessResponse {}
+export const AuthorizeOverTheBoxRemoteAccessResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "AuthorizeOverTheBoxRemoteAccessResponse",
+}) as any as S.Schema<AuthorizeOverTheBoxRemoteAccessResponse>;
+
+export interface CancelOverTheBoxResiliationRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+}
+export const CancelOverTheBoxResiliationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/overTheBox/{serviceName}/cancelResiliation",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CancelOverTheBoxResiliationRequest",
+}) as any as S.Schema<CancelOverTheBoxResiliationRequest>;
+
+export interface CancelOverTheBoxResiliationResponse {}
+export const CancelOverTheBoxResiliationResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "CancelOverTheBoxResiliationResponse",
+}) as any as S.Schema<CancelOverTheBoxResiliationResponse>;
+
+export interface CreateOverTheBoxChangeContactRequest {
+  /** The internal name of your overTheBox offer */
+  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 CreateOverTheBoxChangeContactRequest = /*@__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: "/overTheBox/{serviceName}/changeContact",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "CreateOverTheBoxChangeContactRequest",
+}) as any as S.Schema<CreateOverTheBoxChangeContactRequest>;
+
+export type CreateOverTheBoxChangeContactResponseBodyList = Array<number>;
+export const CreateOverTheBoxChangeContactResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.Number,
+  ) as any as S.Schema<CreateOverTheBoxChangeContactResponseBodyList>;
+
+export type CreateOverTheBoxChangeContactResponse =
+  CreateOverTheBoxChangeContactResponseBodyList;
+export const CreateOverTheBoxChangeContactResponse = /*@__PURE__*/ S.suspend(
+  () => CreateOverTheBoxChangeContactResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateOverTheBoxChangeContactResponse",
+}) as any as S.Schema<CreateOverTheBoxChangeContactResponse>;
+
+export interface CreateOverTheBoxDeviceRequest {}
+export const CreateOverTheBoxDeviceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "POST", uri: "/overTheBox/devices", code: 200 }),
+  ),
+).annotate({
+  identifier: "CreateOverTheBoxDeviceRequest",
+}) as any as S.Schema<CreateOverTheBoxDeviceRequest>;
+
+/** A device for registration */
+export interface OverTheBoxDeviceForRegistration {
+  /** Whether or not this device is actived */
+  activated?: boolean;
+  deviceId?: string;
+  /** The last time this device was seen on the provisionning servers */
+  lastSeen?: string;
+}
+export const OverTheBoxDeviceForRegistration = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    activated: S.optional(S.Boolean),
+    deviceId: S.optional(S.String),
+    lastSeen: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "OverTheBoxDeviceForRegistration",
+}) as any as S.Schema<OverTheBoxDeviceForRegistration>;
+
+export type CreateOverTheBoxDeviceResponseBodyList =
+  Array<OverTheBoxDeviceForRegistration>;
+export const CreateOverTheBoxDeviceResponseBodyList = /*@__PURE__*/ S.Array(
+  OverTheBoxDeviceForRegistration,
+) as any as S.Schema<CreateOverTheBoxDeviceResponseBodyList>;
+
+export type CreateOverTheBoxDeviceResponse =
+  CreateOverTheBoxDeviceResponseBodyList;
+export const CreateOverTheBoxDeviceResponse = /*@__PURE__*/ S.suspend(() =>
+  CreateOverTheBoxDeviceResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateOverTheBoxDeviceResponse",
+}) as any as S.Schema<CreateOverTheBoxDeviceResponse>;
+
+export interface CreateOverTheBoxDeviceActionRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+  /** Name of the action */
+  name: string;
+}
+export const CreateOverTheBoxDeviceActionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    name: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/overTheBox/{serviceName}/device/actions",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateOverTheBoxDeviceActionRequest",
+}) as any as S.Schema<CreateOverTheBoxDeviceActionRequest>;
+
+/** Status of a task. */
+export type OverTheBoxActionStatusEnum = "doing" | "done" | "error" | "todo";
+export const OverTheBoxActionStatusEnum = /*@__PURE__*/ S.String;
+
+/** Device action */
+export interface OverTheBoxDeviceAction {
+  /** The id of the action */
+  actionId?: string;
+  /** Date of creation of the action */
+  createdAt?: string;
+  /** The details of the action */
+  details?: string;
+  /** The name of the action */
+  name?: string;
+  /** The status of the action */
+  status?: OverTheBoxActionStatusEnum;
+  /** Date of execution of the action */
+  todoDate?: string;
+  /** Last time the action was updated */
+  updatedAt?: string;
+}
+export const OverTheBoxDeviceAction = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    actionId: S.optional(S.String),
+    createdAt: S.optional(S.String),
+    details: S.optional(S.String),
+    name: S.optional(S.String),
+    status: S.optional(OverTheBoxActionStatusEnum),
+    todoDate: S.optional(S.String),
+    updatedAt: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "OverTheBoxDeviceAction",
+}) as any as S.Schema<OverTheBoxDeviceAction>;
+
+export interface CreateOverTheBoxDeviceBackupRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+}
+export const CreateOverTheBoxDeviceBackupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/overTheBox/{serviceName}/device/backup",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateOverTheBoxDeviceBackupRequest",
+}) as any as S.Schema<CreateOverTheBoxDeviceBackupRequest>;
+
+export interface CreateOverTheBoxDeviceLogRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+}
+export const CreateOverTheBoxDeviceLogRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/overTheBox/{serviceName}/device/logs",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateOverTheBoxDeviceLogRequest",
+}) as any as S.Schema<CreateOverTheBoxDeviceLogRequest>;
+
+/** Temporary url informations */
+export interface OverTheBoxTemporaryLogsLink {
+  /** Temporary url expiration date */
+  expirationDate?: string;
+  /** Temporary url */
+  url?: string;
+}
+export const OverTheBoxTemporaryLogsLink = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    expirationDate: S.optional(S.String),
+    url: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "OverTheBoxTemporaryLogsLink",
+}) as any as S.Schema<OverTheBoxTemporaryLogsLink>;
+
+export interface CreateOverTheBoxLinkDeviceRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+  /** The id of the device */
+  deviceId: string;
+}
+export const CreateOverTheBoxLinkDeviceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    deviceId: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/overTheBox/{serviceName}/linkDevice",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateOverTheBoxLinkDeviceRequest",
+}) as any as S.Schema<CreateOverTheBoxLinkDeviceRequest>;
+
+export interface CreateOverTheBoxLinkDeviceResponse {}
+export const CreateOverTheBoxLinkDeviceResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "CreateOverTheBoxLinkDeviceResponse",
+}) as any as S.Schema<CreateOverTheBoxLinkDeviceResponse>;
+
+export interface CreateOverTheBoxLinkHardwareRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+  /** The internal name of your hardware */
+  hardwareName: string;
+}
+export const CreateOverTheBoxLinkHardwareRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    hardwareName: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/overTheBox/{serviceName}/linkHardware",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateOverTheBoxLinkHardwareRequest",
+}) as any as S.Schema<CreateOverTheBoxLinkHardwareRequest>;
+
+export interface CreateOverTheBoxLinkHardwareResponse {}
+export const CreateOverTheBoxLinkHardwareResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "CreateOverTheBoxLinkHardwareResponse",
+}) as any as S.Schema<CreateOverTheBoxLinkHardwareResponse>;
+
+export interface CreateOverTheBoxMigrationChangeOfferRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+  /** Name of the hardware */
+  hardwareName?: string;
+  /** Offer name to migrate to */
+  offer: string;
+  /** In case of hardware and if a shipping custom address is desired */
+  shippingContactID?: string;
+}
+export const CreateOverTheBoxMigrationChangeOfferRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      hardwareName: S.optional(S.String),
+      offer: S.String,
+      shippingContactID: S.optional(S.String),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/overTheBox/{serviceName}/migration/changeOffers",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateOverTheBoxMigrationChangeOfferRequest",
+  }) as any as S.Schema<CreateOverTheBoxMigrationChangeOfferRequest>;
+
+/** Migration order */
+export interface OverTheBoxOrderMigration {
+  /** Id of the migration order */
+  orderId?: string;
+  /** URL of the migration order */
+  orderUrl?: string;
+}
+export const OverTheBoxOrderMigration = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    orderId: S.optional(S.String),
+    orderUrl: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "OverTheBoxOrderMigration",
+}) as any as S.Schema<OverTheBoxOrderMigration>;
+
+export interface CreateOverTheBoxRemoteAccessRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+  /** IP block from which the remote access will be allowed (the default value is the IP from which the call is made) */
+  allowedIp?: string;
+  /** The expirationDate of the remote access (default 1 day) */
+  expirationDate?: string;
+  /** The port that the device will expose */
+  exposedPort: number;
+  /** The remote user public key authorized on the device (for SSH purpose) */
+  publicKey?: string;
+}
+export const CreateOverTheBoxRemoteAccessRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    allowedIp: S.optional(S.String),
+    expirationDate: S.optional(S.String),
+    exposedPort: S.Number,
+    publicKey: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/overTheBox/{serviceName}/remoteAccesses",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateOverTheBoxRemoteAccessRequest",
+}) as any as S.Schema<CreateOverTheBoxRemoteAccessRequest>;
+
+/** All the infos needed to connect yourself to your OTB */
+export interface OverTheBoxRemoteAccessConnectionInfos {
+  /** IP to connect to when accessing the device remotely */
+  ip?: string | null;
+  /** Port to connect to when accessing the device remotely */
+  port?: number | null;
+}
+export const OverTheBoxRemoteAccessConnectionInfos = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      ip: S.optional(S.NullOr(S.String)),
+      port: S.optional(S.NullOr(S.Number)),
+    }),
+).annotate({
+  identifier: "OverTheBoxRemoteAccessConnectionInfos",
+}) as any as S.Schema<OverTheBoxRemoteAccessConnectionInfos>;
+
+/** Infos about the remote user */
+export interface OverTheBoxRemoteAccessUserInfos {
+  /** IP from which the remote access will be allowed */
+  ip?: string;
+  /** The public key authorized on the device (for SSH purpose) */
+  publicKey?: string | null;
+  /** The user that will access the device remotely */
+  user?: string;
+}
+export const OverTheBoxRemoteAccessUserInfos = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ip: S.optional(S.String),
+    publicKey: S.optional(S.NullOr(S.String)),
+    user: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "OverTheBoxRemoteAccessUserInfos",
+}) as any as S.Schema<OverTheBoxRemoteAccessUserInfos>;
+
+/** Status of the remote access. */
+export type OverTheBoxRemoteAccessStatusEnum =
+  | "active"
+  | "creating"
+  | "deleted"
+  | "deleting"
+  | "pendingValidation"
+  | "recreating"
+  | "toDelete"
+  | "toRecreate";
+export const OverTheBoxRemoteAccessStatusEnum = /*@__PURE__*/ S.String;
+
+/** If authorized, a remote access will expose a port, allowing an access to the device remotely */
+export interface OverTheBoxRemoteAccess {
+  /** If the remote access was accepted by the remote user */
+  accepted?: boolean;
+  /** The date of the remote access demand */
+  askDate?: string;
+  /** The user that authorized the remote access */
+  authorizedBy?: string | null;
+  /** All the infos needed to connect yourself to your OTB */
+  connectionInfos?: OverTheBoxRemoteAccessConnectionInfos;
+  /** When the remote access was deleted */
+  deletedAt?: string | null;
+  /** Info about the docker version */
+  dockerVersion?: string;
+  /** When the remote access will be automatically deleted */
+  expirationDate?: string;
+  /** The device's port which will be exposed */
+  exposedPort?: number;
+  /** The id of the remote access */
+  remoteAccessId?: string;
+  /** Infos about the remote user */
+  remoteUserInfos?: OverTheBoxRemoteAccessUserInfos;
+  /** Status of the remote access */
+  status?: OverTheBoxRemoteAccessStatusEnum;
+}
+export const OverTheBoxRemoteAccess = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    accepted: S.optional(S.Boolean),
+    askDate: S.optional(S.String),
+    authorizedBy: S.optional(S.NullOr(S.String)),
+    connectionInfos: S.optional(OverTheBoxRemoteAccessConnectionInfos),
+    deletedAt: S.optional(S.NullOr(S.String)),
+    dockerVersion: S.optional(S.String),
+    expirationDate: S.optional(S.String),
+    exposedPort: S.optional(S.Number),
+    remoteAccessId: S.optional(S.String),
+    remoteUserInfos: S.optional(OverTheBoxRemoteAccessUserInfos),
+    status: S.optional(OverTheBoxRemoteAccessStatusEnum),
+  }),
+).annotate({
+  identifier: "OverTheBoxRemoteAccess",
+}) as any as S.Schema<OverTheBoxRemoteAccess>;
+
+export interface DeleteOverTheBoxRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+}
+export const DeleteOverTheBoxRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "DELETE", uri: "/overTheBox/{serviceName}", code: 200 }),
+  ),
+).annotate({
+  identifier: "DeleteOverTheBoxRequest",
+}) as any as S.Schema<DeleteOverTheBoxRequest>;
+
+export interface DeleteOverTheBoxResponse {}
+export const DeleteOverTheBoxResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteOverTheBoxResponse",
+}) as any as S.Schema<DeleteOverTheBoxResponse>;
+
+export interface DeleteOverTheBoxBackupRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+  /** The id of the backup */
+  backupId: string;
+}
+export const DeleteOverTheBoxBackupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    backupId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/overTheBox/{serviceName}/backups/{backupId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteOverTheBoxBackupRequest",
+}) as any as S.Schema<DeleteOverTheBoxBackupRequest>;
+
+export interface DeleteOverTheBoxBackupResponse {}
+export const DeleteOverTheBoxBackupResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteOverTheBoxBackupResponse",
+}) as any as S.Schema<DeleteOverTheBoxBackupResponse>;
+
+export interface DeleteOverTheBoxDeviceRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+}
+export const DeleteOverTheBoxDeviceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/overTheBox/{serviceName}/device",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteOverTheBoxDeviceRequest",
+}) as any as S.Schema<DeleteOverTheBoxDeviceRequest>;
+
+export interface DeleteOverTheBoxDeviceResponse {}
+export const DeleteOverTheBoxDeviceResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteOverTheBoxDeviceResponse",
+}) as any as S.Schema<DeleteOverTheBoxDeviceResponse>;
+
+export interface DeleteOverTheBoxRemoteAccessRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+  /** The id of the remote access */
+  remoteAccessId: string;
+}
+export const DeleteOverTheBoxRemoteAccessRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    remoteAccessId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/overTheBox/{serviceName}/remoteAccesses/{remoteAccessId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteOverTheBoxRemoteAccessRequest",
+}) as any as S.Schema<DeleteOverTheBoxRemoteAccessRequest>;
+
+export interface DeleteOverTheBoxRemoteAccessResponse {}
+export const DeleteOverTheBoxRemoteAccessResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "DeleteOverTheBoxRemoteAccessResponse",
+}) as any as S.Schema<DeleteOverTheBoxRemoteAccessResponse>;
+
+export interface GetOverTheBoxRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+}
+export const GetOverTheBoxRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/overTheBox/{serviceName}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetOverTheBoxRequest",
+}) as any as S.Schema<GetOverTheBoxRequest>;
+
+/** Status of the service */
+export type OverTheBoxAvailableStatusEnum = "disabled" | "enabled";
+export const OverTheBoxAvailableStatusEnum = /*@__PURE__*/ S.String;
+
+/** Configuration mode of the service */
+export type OverTheBoxServiceConfigurationModeEnum = "autoconfigure" | "local";
+export const OverTheBoxServiceConfigurationModeEnum = /*@__PURE__*/ S.String;
+
+/** Parameters required to query metrics from OpenTSDB */
+export interface OverTheBoxGraphEndpoint {
+  /** The OpenTSDB host */
+  host?: string;
+  /** A read-only token */
+  readToken?: string;
+  /** The read-only token ID */
+  readTokenID?: string;
+}
+export const OverTheBoxGraphEndpoint = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    host: S.optional(S.String),
+    readToken: S.optional(S.String),
+    readTokenID: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "OverTheBoxGraphEndpoint",
+}) as any as S.Schema<OverTheBoxGraphEndpoint>;
+
+/** 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>;
+
+/** Status of the service. */
+export type OverTheBoxServiceStatusEnum =
+  | "active"
+  | "creating"
+  | "deleted"
+  | "suspended"
+  | "toCreate"
+  | "toDelete";
+export const OverTheBoxServiceStatusEnum = /*@__PURE__*/ S.String;
+
+/** Tunnel mode of the service. */
+export type OverTheBoxTunnelModeEnum =
+  | "glorytun"
+  | "glorytun_hybrid"
+  | "glorytun_mud";
+export const OverTheBoxTunnelModeEnum = /*@__PURE__*/ S.String;
+
+/** Service */
+export interface OverTheBoxServiceWithIAM {
+  /** If the socks proxy is enabled */
+  SOCKSProxyEnabled?: boolean;
+  /** The status of the autoMTU */
+  autoMTU?: OverTheBoxAvailableStatusEnum;
+  /** Enable device auto upgrade */
+  autoUpgrade?: boolean;
+  /** The service maximum bandwidth in bits */
+  bandwidth?: number;
+  /** Configuration mode of the service */
+  configurationMode?: OverTheBoxServiceConfigurationModeEnum;
+  /** Editable field for customer */
+  customerDescription?: string | null;
+  /** Parameters needed to fetch metrics */
+  graphEndpoint?: OverTheBoxGraphEndpoint | null;
+  /** IAM resource metadata */
+  iam?: IamResourceMetadata | null;
+  /** Indicates if IPv6 is enabled */
+  ipv6Enabled?: boolean;
+  /** The service offer */
+  offer?: string;
+  /** The service pretty offer name */
+  prettyOfferName?: string;
+  /** Release channel of the service */
+  releaseChannel?: string;
+  /** The name of the service */
+  serviceName?: string;
+  /** The status of the service */
+  status?: OverTheBoxServiceStatusEnum;
+  /** The tunnel mode of the service */
+  tunnelMode?: OverTheBoxTunnelModeEnum;
+}
+export const OverTheBoxServiceWithIAM = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    SOCKSProxyEnabled: S.optional(S.Boolean),
+    autoMTU: S.optional(OverTheBoxAvailableStatusEnum),
+    autoUpgrade: S.optional(S.Boolean),
+    bandwidth: S.optional(S.Number),
+    configurationMode: S.optional(OverTheBoxServiceConfigurationModeEnum),
+    customerDescription: S.optional(S.NullOr(S.String)),
+    graphEndpoint: S.optional(S.NullOr(OverTheBoxGraphEndpoint)),
+    iam: S.optional(S.NullOr(IamResourceMetadata)),
+    ipv6Enabled: S.optional(S.Boolean),
+    offer: S.optional(S.String),
+    prettyOfferName: S.optional(S.String),
+    releaseChannel: S.optional(S.String),
+    serviceName: S.optional(S.String),
+    status: S.optional(OverTheBoxServiceStatusEnum),
+    tunnelMode: S.optional(OverTheBoxTunnelModeEnum),
+  }),
+).annotate({
+  identifier: "OverTheBoxServiceWithIAM",
+}) as any as S.Schema<OverTheBoxServiceWithIAM>;
+
+export interface GetOverTheBoxBackupRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+  /** The id of the backup */
+  backupId: string;
+}
+export const GetOverTheBoxBackupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    backupId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/overTheBox/{serviceName}/backups/{backupId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetOverTheBoxBackupRequest",
+}) as any as S.Schema<GetOverTheBoxBackupRequest>;
+
+/** Backup */
+export interface OverTheBoxBackup {
+  /** The id of the backup */
+  backupId?: string;
+  /** Date of the creation of the backup */
+  createdAt?: string;
+  /** The id of the device action that triggered the backup */
+  deviceActionId?: string | null;
+}
+export const OverTheBoxBackup = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    backupId: S.optional(S.String),
+    createdAt: S.optional(S.String),
+    deviceActionId: S.optional(S.NullOr(S.String)),
+  }),
+).annotate({
+  identifier: "OverTheBoxBackup",
+}) as any as S.Schema<OverTheBoxBackup>;
+
+export interface GetOverTheBoxDeviceRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+}
+export const GetOverTheBoxDeviceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/overTheBox/{serviceName}/device",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetOverTheBoxDeviceRequest",
+}) as any as S.Schema<GetOverTheBoxDeviceRequest>;
+
+/** The DNS servers of this interface */
+export type OverTheBoxDeviceInterfaceDnsServersList = Array<string>;
+export const OverTheBoxDeviceInterfaceDnsServersList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<OverTheBoxDeviceInterfaceDnsServersList>;
+
+/** Status of a MPTCP Interface. */
+export type OverTheBoxMultipathStatusEnum =
+  | "backup"
+  | "handover"
+  | "master"
+  | "off"
+  | "on";
+export const OverTheBoxMultipathStatusEnum = /*@__PURE__*/ S.String;
+
+/** Infos about a network interface */
+export interface OverTheBoxDeviceInterface {
+  /** Device of the interface */
+  device?: string | null;
+  /** The DNS servers of this interface */
+  dnsServers?: OverTheBoxDeviceInterfaceDnsServersList | null;
+  /** Gateway of the interface */
+  gateway?: string | null;
+  /** IP of the interface */
+  ip?: string | null;
+  /** Status of MPTCP on this interface */
+  multipathStatus?: OverTheBoxMultipathStatusEnum;
+  /** Name of the interface */
+  name?: string;
+  /** Netmask of the interface */
+  netmask?: string | null;
+  /** Public IP of the interface */
+  publicIp?: string | null;
+}
+export const OverTheBoxDeviceInterface = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    device: S.optional(S.NullOr(S.String)),
+    dnsServers: S.optional(S.NullOr(OverTheBoxDeviceInterfaceDnsServersList)),
+    gateway: S.optional(S.NullOr(S.String)),
+    ip: S.optional(S.NullOr(S.String)),
+    multipathStatus: S.optional(OverTheBoxMultipathStatusEnum),
+    name: S.optional(S.String),
+    netmask: S.optional(S.NullOr(S.String)),
+    publicIp: S.optional(S.NullOr(S.String)),
+  }),
+).annotate({
+  identifier: "OverTheBoxDeviceInterface",
+}) as any as S.Schema<OverTheBoxDeviceInterface>;
+
+/** Network interfaces of the device */
+export type OverTheBoxDeviceNetworkInterfacesList =
+  Array<OverTheBoxDeviceInterface>;
+export const OverTheBoxDeviceNetworkInterfacesList = /*@__PURE__*/ S.Array(
+  OverTheBoxDeviceInterface,
+) as any as S.Schema<OverTheBoxDeviceNetworkInterfacesList>;
+
+/** Infos about a device system */
+export interface OverTheBoxDeviceSystem {
+  /** Device CPU */
+  cpu?: string | null;
+  /** Device hostname */
+  hostname?: string | null;
+  /** Device linux kernel version */
+  kernel?: string | null;
+  /** Device mac address (first interface mac) */
+  mac?: string | null;
+  /** Device model */
+  model?: string | null;
+  /** Name of the device board */
+  name?: string | null;
+  /** OVH offer name of the device board */
+  offerName?: string | null;
+  /** OVH name of the device board */
+  ovhName?: string | null;
+}
+export const OverTheBoxDeviceSystem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cpu: S.optional(S.NullOr(S.String)),
+    hostname: S.optional(S.NullOr(S.String)),
+    kernel: S.optional(S.NullOr(S.String)),
+    mac: S.optional(S.NullOr(S.String)),
+    model: S.optional(S.NullOr(S.String)),
+    name: S.optional(S.NullOr(S.String)),
+    offerName: S.optional(S.NullOr(S.String)),
+    ovhName: S.optional(S.NullOr(S.String)),
+  }),
+).annotate({
+  identifier: "OverTheBoxDeviceSystem",
+}) as any as S.Schema<OverTheBoxDeviceSystem>;
+
+/** Device */
+export interface OverTheBoxDevice {
+  /** Whether or not this device is associated to a service */
+  activated?: boolean;
+  /** Whether or not an upate is available for this device */
+  availableUpdate?: boolean;
+  /** The id of the device */
+  deviceId?: string;
+  /** Last time the device has been seen on the provisionning servers */
+  lastSeen?: string;
+  /** Network interfaces of the device */
+  networkInterfaces?: OverTheBoxDeviceNetworkInterfacesList;
+  /** The public IP of the device */
+  publicIp?: string;
+  /** Device system information */
+  system?: OverTheBoxDeviceSystem | null;
+  /** System version of the device */
+  systemVersion?: string;
+  /** Version of the device */
+  version?: string;
+}
+export const OverTheBoxDevice = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    activated: S.optional(S.Boolean),
+    availableUpdate: S.optional(S.Boolean),
+    deviceId: S.optional(S.String),
+    lastSeen: S.optional(S.String),
+    networkInterfaces: S.optional(OverTheBoxDeviceNetworkInterfacesList),
+    publicIp: S.optional(S.String),
+    system: S.optional(S.NullOr(OverTheBoxDeviceSystem)),
+    systemVersion: S.optional(S.String),
+    version: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "OverTheBoxDevice",
+}) as any as S.Schema<OverTheBoxDevice>;
+
+export interface GetOverTheBoxDeviceActionRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+  /** The id of the action */
+  actionId: string;
+}
+export const GetOverTheBoxDeviceActionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    actionId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/overTheBox/{serviceName}/device/actions/{actionId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetOverTheBoxDeviceActionRequest",
+}) as any as S.Schema<GetOverTheBoxDeviceActionRequest>;
+
+export interface GetOverTheBoxDeviceHardwareRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+}
+export const GetOverTheBoxDeviceHardwareRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/overTheBox/{serviceName}/device/hardware",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetOverTheBoxDeviceHardwareRequest",
+}) as any as S.Schema<GetOverTheBoxDeviceHardwareRequest>;
+
+/** Hardware properties */
+export interface OverTheBoxHardware {
+  /** True if hardware can be linked to a service without deviceID */
+  canBeLinkedToService?: boolean;
+  /** Hardware MAC address */
+  mac?: string | null;
+  /** Hardware model */
+  model?: string;
+  /** Hardware name */
+  name?: string;
+  /** The hardware pretty model name */
+  prettyModelName?: string;
+  /** Hardware serial */
+  serial?: string;
+}
+export const OverTheBoxHardware = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    canBeLinkedToService: S.optional(S.Boolean),
+    mac: S.optional(S.NullOr(S.String)),
+    model: S.optional(S.String),
+    name: S.optional(S.String),
+    prettyModelName: S.optional(S.String),
+    serial: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "OverTheBoxHardware",
+}) as any as S.Schema<OverTheBoxHardware>;
+
+export interface GetOverTheBoxHardwareRequest {
+  /** The internal name of your hardware */
+  hardwareName: string;
+}
+export const GetOverTheBoxHardwareRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    hardwareName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/overTheBox/hardware/{hardwareName}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetOverTheBoxHardwareRequest",
+}) as any as S.Schema<GetOverTheBoxHardwareRequest>;
+
+/** Hardware properties */
+export interface OverTheBoxHardwareWithIAM {
+  /** True if hardware can be linked to a service without deviceID */
+  canBeLinkedToService?: boolean;
+  /** IAM resource metadata */
+  iam?: IamResourceMetadata | null;
+  /** Hardware MAC address */
+  mac?: string | null;
+  /** Hardware model */
+  model?: string;
+  /** Hardware name */
+  name?: string;
+  /** The hardware pretty model name */
+  prettyModelName?: string;
+  /** Hardware serial */
+  serial?: string;
+}
+export const OverTheBoxHardwareWithIAM = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    canBeLinkedToService: S.optional(S.Boolean),
+    iam: S.optional(S.NullOr(IamResourceMetadata)),
+    mac: S.optional(S.NullOr(S.String)),
+    model: S.optional(S.String),
+    name: S.optional(S.String),
+    prettyModelName: S.optional(S.String),
+    serial: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "OverTheBoxHardwareWithIAM",
+}) as any as S.Schema<OverTheBoxHardwareWithIAM>;
+
+export interface GetOverTheBoxIpsRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+  /** Ip */
+  ip: string;
+}
+export const GetOverTheBoxIpsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    ip: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/overTheBox/{serviceName}/ips/{ip}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetOverTheBoxIpsRequest",
+}) as any as S.Schema<GetOverTheBoxIpsRequest>;
+
+/** IP geolocation */
+export type OtbServiceIpGeolocationEnum = "fr";
+export const OtbServiceIpGeolocationEnum = /*@__PURE__*/ S.String;
+
+/** IP status */
+export type OtbServiceIpStatusEnum =
+  | "active"
+  | "free"
+  | "pendingRelease"
+  | "released"
+  | "reserved";
+export const OtbServiceIpStatusEnum = /*@__PURE__*/ S.String;
+
+/** IP version */
+export type OtbServiceIpVersionEnum = "v4" | "v6";
+export const OtbServiceIpVersionEnum = /*@__PURE__*/ S.String;
+
+/** Service IP details */
+export interface OtbServiceIp {
+  /** IP geolocation */
+  geolocation?: OtbServiceIpGeolocationEnum;
+  /** IP address */
+  ip?: string;
+  /** IP cidr prefix */
+  range?: number;
+  /** IP status */
+  status?: OtbServiceIpStatusEnum;
+  /** IP version */
+  version?: OtbServiceIpVersionEnum;
+}
+export const OtbServiceIp = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    geolocation: S.optional(OtbServiceIpGeolocationEnum),
+    ip: S.optional(S.String),
+    range: S.optional(S.Number),
+    status: S.optional(OtbServiceIpStatusEnum),
+    version: S.optional(OtbServiceIpVersionEnum),
+  }),
+).annotate({ identifier: "OtbServiceIp" }) as any as S.Schema<OtbServiceIp>;
+
+export interface GetOverTheBoxRemoteAccessRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+  /** The id of the remote access */
+  remoteAccessId: string;
+}
+export const GetOverTheBoxRemoteAccessRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    remoteAccessId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/overTheBox/{serviceName}/remoteAccesses/{remoteAccessId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetOverTheBoxRemoteAccessRequest",
+}) as any as S.Schema<GetOverTheBoxRemoteAccessRequest>;
+
+export interface GetOverTheBoxServiceInfosRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+}
+export const GetOverTheBoxServiceInfosRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/overTheBox/{serviceName}/serviceInfos",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetOverTheBoxServiceInfosRequest",
+}) as any as S.Schema<GetOverTheBoxServiceInfosRequest>;
+
+/** 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 GetOverTheBoxTaskRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+  /** The id of the task */
+  taskId: string;
+}
+export const GetOverTheBoxTaskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    taskId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/overTheBox/{serviceName}/tasks/{taskId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetOverTheBoxTaskRequest",
+}) as any as S.Schema<GetOverTheBoxTaskRequest>;
+
+/** Status of a task. */
+export type OverTheBoxTaskStatusEnum = "doing" | "done" | "error" | "todo";
+export const OverTheBoxTaskStatusEnum = /*@__PURE__*/ S.String;
+
+/** Task */
+export interface OverTheBoxTask {
+  /** The name of the task */
+  name?: string;
+  /** The status of the task */
+  status?: OverTheBoxTaskStatusEnum;
+  /** The id of the task */
+  taskId?: string;
+}
+export const OverTheBoxTask = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.optional(S.String),
+    status: S.optional(OverTheBoxTaskStatusEnum),
+    taskId: S.optional(S.String),
+  }),
+).annotate({ identifier: "OverTheBoxTask" }) as any as S.Schema<OverTheBoxTask>;
+
+/** 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 ListOverTheBoxRequestIamTagsValueList =
+  Array<IamResourceTagFilterInput>;
+export const ListOverTheBoxRequestIamTagsValueList = /*@__PURE__*/ S.Array(
+  IamResourceTagFilterInput,
+) as any as S.Schema<ListOverTheBoxRequestIamTagsValueList>;
+
+export type ListOverTheBoxRequestIamTagsMap = {
+  [key: string]: ListOverTheBoxRequestIamTagsValueList | undefined;
+};
+export const ListOverTheBoxRequestIamTagsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  ListOverTheBoxRequestIamTagsValueList,
+) as any as S.Schema<ListOverTheBoxRequestIamTagsMap>;
+
+export interface ListOverTheBoxRequest {
+  /** Filter resources on IAM tags */
+  iamTags?: ListOverTheBoxRequestIamTagsMap;
+}
+export const ListOverTheBoxRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    iamTags: S.optional(ListOverTheBoxRequestIamTagsMap.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/overTheBox", code: 200 })),
+).annotate({
+  identifier: "ListOverTheBoxRequest",
+}) as any as S.Schema<ListOverTheBoxRequest>;
+
+export type ListOverTheBoxResponseBodyList = Array<string>;
+export const ListOverTheBoxResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListOverTheBoxResponseBodyList>;
+
+export type ListOverTheBoxResponse = ListOverTheBoxResponseBodyList;
+export const ListOverTheBoxResponse = /*@__PURE__*/ S.suspend(() =>
+  ListOverTheBoxResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListOverTheBoxResponse",
+}) as any as S.Schema<ListOverTheBoxResponse>;
+
+export interface ListOverTheBoxAvailableOffersRequest {}
+export const ListOverTheBoxAvailableOffersRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({}).pipe(
+      T.Http({ method: "GET", uri: "/overTheBox/availableOffers", code: 200 }),
+    ),
+).annotate({
+  identifier: "ListOverTheBoxAvailableOffersRequest",
+}) as any as S.Schema<ListOverTheBoxAvailableOffersRequest>;
+
+/** Enum of Offers */
+export type PriceOverTheBoxOfferEnum = "business.v1" | "plus.v1" | "starter.v1";
+export const PriceOverTheBoxOfferEnum = /*@__PURE__*/ S.String;
+
+export type ListOverTheBoxAvailableOffersResponseBodyList =
+  Array<PriceOverTheBoxOfferEnum>;
+export const ListOverTheBoxAvailableOffersResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    PriceOverTheBoxOfferEnum,
+  ) as any as S.Schema<ListOverTheBoxAvailableOffersResponseBodyList>;
+
+export type ListOverTheBoxAvailableOffersResponse =
+  ListOverTheBoxAvailableOffersResponseBodyList;
+export const ListOverTheBoxAvailableOffersResponse = /*@__PURE__*/ S.suspend(
+  () => ListOverTheBoxAvailableOffersResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListOverTheBoxAvailableOffersResponse",
+}) as any as S.Schema<ListOverTheBoxAvailableOffersResponse>;
+
+export interface ListOverTheBoxAvailableReleaseChannelsRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+}
+export const ListOverTheBoxAvailableReleaseChannelsRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/overTheBox/{serviceName}/availableReleaseChannels",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListOverTheBoxAvailableReleaseChannelsRequest",
+  }) as any as S.Schema<ListOverTheBoxAvailableReleaseChannelsRequest>;
+
+export type ListOverTheBoxAvailableReleaseChannelsResponseBodyList =
+  Array<string>;
+export const ListOverTheBoxAvailableReleaseChannelsResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListOverTheBoxAvailableReleaseChannelsResponseBodyList>;
+
+export type ListOverTheBoxAvailableReleaseChannelsResponse =
+  ListOverTheBoxAvailableReleaseChannelsResponseBodyList;
+export const ListOverTheBoxAvailableReleaseChannelsResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListOverTheBoxAvailableReleaseChannelsResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListOverTheBoxAvailableReleaseChannelsResponse",
+  }) as any as S.Schema<ListOverTheBoxAvailableReleaseChannelsResponse>;
+
+export interface ListOverTheBoxBackupsRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+}
+export const ListOverTheBoxBackupsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/overTheBox/{serviceName}/backups",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListOverTheBoxBackupsRequest",
+}) as any as S.Schema<ListOverTheBoxBackupsRequest>;
+
+export type ListOverTheBoxBackupsResponseBodyList = Array<string>;
+export const ListOverTheBoxBackupsResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListOverTheBoxBackupsResponseBodyList>;
+
+export type ListOverTheBoxBackupsResponse =
+  ListOverTheBoxBackupsResponseBodyList;
+export const ListOverTheBoxBackupsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListOverTheBoxBackupsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListOverTheBoxBackupsResponse",
+}) as any as S.Schema<ListOverTheBoxBackupsResponse>;
+
+export interface ListOverTheBoxDeviceActionsRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+  /** Filter the value of name property (=) */
+  name?: string;
+  /** Filter the value of status property (=) */
+  status?: OverTheBoxActionStatusEnum | (string & {});
+}
+export const ListOverTheBoxDeviceActionsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    name: S.optional(S.String.pipe(T.Query())),
+    status: S.optional(OverTheBoxActionStatusEnum.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/overTheBox/{serviceName}/device/actions",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListOverTheBoxDeviceActionsRequest",
+}) as any as S.Schema<ListOverTheBoxDeviceActionsRequest>;
+
+export type ListOverTheBoxDeviceActionsResponseBodyList = Array<string>;
+export const ListOverTheBoxDeviceActionsResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListOverTheBoxDeviceActionsResponseBodyList>;
+
+export type ListOverTheBoxDeviceActionsResponse =
+  ListOverTheBoxDeviceActionsResponseBodyList;
+export const ListOverTheBoxDeviceActionsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListOverTheBoxDeviceActionsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListOverTheBoxDeviceActionsResponse",
+}) as any as S.Schema<ListOverTheBoxDeviceActionsResponse>;
+
+export interface ListOverTheBoxDeviceAvailableActionsRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+}
+export const ListOverTheBoxDeviceAvailableActionsRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/overTheBox/{serviceName}/device/availableActions",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListOverTheBoxDeviceAvailableActionsRequest",
+  }) as any as S.Schema<ListOverTheBoxDeviceAvailableActionsRequest>;
+
+/** Device action */
+export interface OverTheBoxAvailableDeviceAction {
+  /** Description of the action */
+  description?: string;
+  /** Name of the action */
+  name?: string;
+}
+export const OverTheBoxAvailableDeviceAction = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    description: S.optional(S.String),
+    name: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "OverTheBoxAvailableDeviceAction",
+}) as any as S.Schema<OverTheBoxAvailableDeviceAction>;
+
+export type ListOverTheBoxDeviceAvailableActionsResponseBodyList =
+  Array<OverTheBoxAvailableDeviceAction>;
+export const ListOverTheBoxDeviceAvailableActionsResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    OverTheBoxAvailableDeviceAction,
+  ) as any as S.Schema<ListOverTheBoxDeviceAvailableActionsResponseBodyList>;
+
+export type ListOverTheBoxDeviceAvailableActionsResponse =
+  ListOverTheBoxDeviceAvailableActionsResponseBodyList;
+export const ListOverTheBoxDeviceAvailableActionsResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListOverTheBoxDeviceAvailableActionsResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListOverTheBoxDeviceAvailableActionsResponse",
+  }) as any as S.Schema<ListOverTheBoxDeviceAvailableActionsResponse>;
+
+export type ListOverTheBoxHardwareRequestIamTagsValueList =
+  Array<IamResourceTagFilterInput>;
+export const ListOverTheBoxHardwareRequestIamTagsValueList =
+  /*@__PURE__*/ S.Array(
+    IamResourceTagFilterInput,
+  ) as any as S.Schema<ListOverTheBoxHardwareRequestIamTagsValueList>;
+
+export type ListOverTheBoxHardwareRequestIamTagsMap = {
+  [key: string]: ListOverTheBoxHardwareRequestIamTagsValueList | undefined;
+};
+export const ListOverTheBoxHardwareRequestIamTagsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  ListOverTheBoxHardwareRequestIamTagsValueList,
+) as any as S.Schema<ListOverTheBoxHardwareRequestIamTagsMap>;
+
+export interface ListOverTheBoxHardwareRequest {
+  /** Filter resources on IAM tags */
+  iamTags?: ListOverTheBoxHardwareRequestIamTagsMap;
+}
+export const ListOverTheBoxHardwareRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    iamTags: S.optional(
+      ListOverTheBoxHardwareRequestIamTagsMap.pipe(T.Query()),
+    ),
+  }).pipe(T.Http({ method: "GET", uri: "/overTheBox/hardware", code: 200 })),
+).annotate({
+  identifier: "ListOverTheBoxHardwareRequest",
+}) as any as S.Schema<ListOverTheBoxHardwareRequest>;
+
+export type ListOverTheBoxHardwareResponseBodyList = Array<string>;
+export const ListOverTheBoxHardwareResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListOverTheBoxHardwareResponseBodyList>;
+
+export type ListOverTheBoxHardwareResponse =
+  ListOverTheBoxHardwareResponseBodyList;
+export const ListOverTheBoxHardwareResponse = /*@__PURE__*/ S.suspend(() =>
+  ListOverTheBoxHardwareResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListOverTheBoxHardwareResponse",
+}) as any as S.Schema<ListOverTheBoxHardwareResponse>;
+
+export interface ListOverTheBoxHardwareAvailableRequest {}
+export const ListOverTheBoxHardwareAvailableRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({}).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/overTheBox/hardware/available",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListOverTheBoxHardwareAvailableRequest",
+}) as any as S.Schema<ListOverTheBoxHardwareAvailableRequest>;
+
+export type ListOverTheBoxHardwareAvailableResponseBodyList = Array<string>;
+export const ListOverTheBoxHardwareAvailableResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListOverTheBoxHardwareAvailableResponseBodyList>;
+
+export type ListOverTheBoxHardwareAvailableResponse =
+  ListOverTheBoxHardwareAvailableResponseBodyList;
+export const ListOverTheBoxHardwareAvailableResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    ListOverTheBoxHardwareAvailableResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListOverTheBoxHardwareAvailableResponse",
+}) as any as S.Schema<ListOverTheBoxHardwareAvailableResponse>;
+
+export interface ListOverTheBoxIpsRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+}
+export const ListOverTheBoxIpsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/overTheBox/{serviceName}/ips", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListOverTheBoxIpsRequest",
+}) as any as S.Schema<ListOverTheBoxIpsRequest>;
+
+export type ListOverTheBoxIpsResponseBodyList = Array<string>;
+export const ListOverTheBoxIpsResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListOverTheBoxIpsResponseBodyList>;
+
+export type ListOverTheBoxIpsResponse = ListOverTheBoxIpsResponseBodyList;
+export const ListOverTheBoxIpsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListOverTheBoxIpsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListOverTheBoxIpsResponse",
+}) as any as S.Schema<ListOverTheBoxIpsResponse>;
+
+export interface ListOverTheBoxMigrationOffersRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+}
+export const ListOverTheBoxMigrationOffersRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/overTheBox/{serviceName}/migration/offers",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListOverTheBoxMigrationOffersRequest",
+}) as any as S.Schema<ListOverTheBoxMigrationOffersRequest>;
+
+export type OrderCurrencyCodeEnum =
+  | "AUD"
+  | "CAD"
+  | "CZK"
+  | "EUR"
+  | "GBP"
+  | "INR"
+  | "LTL"
+  | "MAD"
+  | "N/A"
+  | "PLN"
+  | "SGD"
+  | "TND"
+  | "USD"
+  | "XOF"
+  | "points";
+export const OrderCurrencyCodeEnum = /*@__PURE__*/ S.String;
+
+/** Price with it's currency and textual representation */
+export interface OrderPrice {
+  currencyCode?: OrderCurrencyCodeEnum;
+  text?: string;
+  value?: number;
+}
+export const OrderPrice = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    currencyCode: S.optional(OrderCurrencyCodeEnum),
+    text: S.optional(S.String),
+    value: S.optional(S.Number),
+  }),
+).annotate({ identifier: "OrderPrice" }) as any as S.Schema<OrderPrice>;
+
+/** Details of available hardwares */
+export interface OverTheBoxHardwareDetails {
+  /** Pretty hardware model name */
+  hardwareDisplayName?: string | null;
+  /** Name of the hardware */
+  hardwareName?: string | null;
+  /** Hardware purchase price */
+  hardwarePrice?: OrderPrice | null;
+}
+export const OverTheBoxHardwareDetails = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    hardwareDisplayName: S.optional(S.NullOr(S.String)),
+    hardwareName: S.optional(S.NullOr(S.String)),
+    hardwarePrice: S.optional(S.NullOr(OrderPrice)),
+  }),
+).annotate({
+  identifier: "OverTheBoxHardwareDetails",
+}) as any as S.Schema<OverTheBoxHardwareDetails>;
+
+/** Details of available hardwares */
+export type OverTheBoxAvailableMigrationOfferHardwaresList =
+  Array<OverTheBoxHardwareDetails>;
+export const OverTheBoxAvailableMigrationOfferHardwaresList =
+  /*@__PURE__*/ S.Array(
+    OverTheBoxHardwareDetails,
+  ) as any as S.Schema<OverTheBoxAvailableMigrationOfferHardwaresList>;
+
+/** Migration offer */
+export interface OverTheBoxAvailableMigrationOffer {
+  /** Monthly price of the current offer */
+  currentOfferPrice?: OrderPrice;
+  /** Description of the offer */
+  description?: string;
+  /** Number of months of engagement */
+  engagementMonths?: number;
+  /** Specify if a hardware is available */
+  hardwareAvailable?: boolean;
+  /** Name of the hardware */
+  hardwareName?: string | null;
+  /** Hardware purchase price */
+  hardwarePrice?: OrderPrice | null;
+  /** Details of available hardwares */
+  hardwares?: OverTheBoxAvailableMigrationOfferHardwaresList;
+  /** Name of the offer */
+  offer?: string;
+  /** Monthly price of the new offer */
+  price?: OrderPrice;
+}
+export const OverTheBoxAvailableMigrationOffer = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    currentOfferPrice: S.optional(OrderPrice),
+    description: S.optional(S.String),
+    engagementMonths: S.optional(S.Number),
+    hardwareAvailable: S.optional(S.Boolean),
+    hardwareName: S.optional(S.NullOr(S.String)),
+    hardwarePrice: S.optional(S.NullOr(OrderPrice)),
+    hardwares: S.optional(OverTheBoxAvailableMigrationOfferHardwaresList),
+    offer: S.optional(S.String),
+    price: S.optional(OrderPrice),
+  }),
+).annotate({
+  identifier: "OverTheBoxAvailableMigrationOffer",
+}) as any as S.Schema<OverTheBoxAvailableMigrationOffer>;
+
+export type ListOverTheBoxMigrationOffersResponseBodyList =
+  Array<OverTheBoxAvailableMigrationOffer>;
+export const ListOverTheBoxMigrationOffersResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    OverTheBoxAvailableMigrationOffer,
+  ) as any as S.Schema<ListOverTheBoxMigrationOffersResponseBodyList>;
+
+export type ListOverTheBoxMigrationOffersResponse =
+  ListOverTheBoxMigrationOffersResponseBodyList;
+export const ListOverTheBoxMigrationOffersResponse = /*@__PURE__*/ S.suspend(
+  () => ListOverTheBoxMigrationOffersResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListOverTheBoxMigrationOffersResponse",
+}) as any as S.Schema<ListOverTheBoxMigrationOffersResponse>;
+
+export interface ListOverTheBoxRemoteAccessesRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+}
+export const ListOverTheBoxRemoteAccessesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/overTheBox/{serviceName}/remoteAccesses",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListOverTheBoxRemoteAccessesRequest",
+}) as any as S.Schema<ListOverTheBoxRemoteAccessesRequest>;
+
+export type ListOverTheBoxRemoteAccessesResponseBodyList = Array<string>;
+export const ListOverTheBoxRemoteAccessesResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListOverTheBoxRemoteAccessesResponseBodyList>;
+
+export type ListOverTheBoxRemoteAccessesResponse =
+  ListOverTheBoxRemoteAccessesResponseBodyList;
+export const ListOverTheBoxRemoteAccessesResponse = /*@__PURE__*/ S.suspend(
+  () => ListOverTheBoxRemoteAccessesResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListOverTheBoxRemoteAccessesResponse",
+}) as any as S.Schema<ListOverTheBoxRemoteAccessesResponse>;
+
+/** Serie Name */
+export type OtbDeviceStatisticsTypeEnum = "load" | "memory_free" | "traffic";
+export const OtbDeviceStatisticsTypeEnum = /*@__PURE__*/ S.String;
+
+/** Statistics Period */
+export type OtbDeviceStatisticsPeriodEnum =
+  | "daily"
+  | "hourly"
+  | "monthly"
+  | "weekly";
+export const OtbDeviceStatisticsPeriodEnum = /*@__PURE__*/ S.String;
+
+export interface ListOverTheBoxStatisticsRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+  /** Type of metrics you want to retrieve */
+  metricsType: OtbDeviceStatisticsTypeEnum | (string & {});
+  /** Period (default is daily) */
+  period?: OtbDeviceStatisticsPeriodEnum | (string & {});
+}
+export const ListOverTheBoxStatisticsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    metricsType: OtbDeviceStatisticsTypeEnum.pipe(T.Query()),
+    period: S.optional(OtbDeviceStatisticsPeriodEnum.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/overTheBox/{serviceName}/statistics",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListOverTheBoxStatisticsRequest",
+}) as any as S.Schema<ListOverTheBoxStatisticsRequest>;
+
+/** Statistics Datapoint */
+export interface OtbDeviceStatisticsPoint {
+  /** Timestamp */
+  timestamp?: number;
+  /** Datapoint value */
+  value?: number | null;
+}
+export const OtbDeviceStatisticsPoint = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    timestamp: S.optional(S.Number),
+    value: S.optional(S.NullOr(S.Number)),
+  }),
+).annotate({
+  identifier: "OtbDeviceStatisticsPoint",
+}) as any as S.Schema<OtbDeviceStatisticsPoint>;
+
+/** List of point */
+export type OtbDeviceStatisticsPointsList = Array<OtbDeviceStatisticsPoint>;
+export const OtbDeviceStatisticsPointsList = /*@__PURE__*/ S.Array(
+  OtbDeviceStatisticsPoint,
+) as any as S.Schema<OtbDeviceStatisticsPointsList>;
+
+/** Tags for the metrics */
+export interface OtbDeviceStatisticsTag {
+  /** Name of tag */
+  name?: string;
+  /** Value of tag */
+  value?: string | null;
+}
+export const OtbDeviceStatisticsTag = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.optional(S.String),
+    value: S.optional(S.NullOr(S.String)),
+  }),
+).annotate({
+  identifier: "OtbDeviceStatisticsTag",
+}) as any as S.Schema<OtbDeviceStatisticsTag>;
+
+/** List of tags */
+export type OtbDeviceStatisticsTagsList = Array<OtbDeviceStatisticsTag>;
+export const OtbDeviceStatisticsTagsList = /*@__PURE__*/ S.Array(
+  OtbDeviceStatisticsTag,
+) as any as S.Schema<OtbDeviceStatisticsTagsList>;
+
+/** Serie Unit */
+export type OtbDeviceStatisticsUnitEnum = "bps" | "byte" | "n/a";
+export const OtbDeviceStatisticsUnitEnum = /*@__PURE__*/ S.String;
+
+/** Device Statistics Datapoints */
+export interface OtbDeviceStatistics {
+  /** Name of the serie */
+  name?: string;
+  /** List of point */
+  points?: OtbDeviceStatisticsPointsList;
+  /** List of tags */
+  tags?: OtbDeviceStatisticsTagsList;
+  /** Unit of the serie */
+  unit?: OtbDeviceStatisticsUnitEnum;
+}
+export const OtbDeviceStatistics = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.optional(S.String),
+    points: S.optional(OtbDeviceStatisticsPointsList),
+    tags: S.optional(OtbDeviceStatisticsTagsList),
+    unit: S.optional(OtbDeviceStatisticsUnitEnum),
+  }),
+).annotate({
+  identifier: "OtbDeviceStatistics",
+}) as any as S.Schema<OtbDeviceStatistics>;
+
+export type ListOverTheBoxStatisticsResponseBodyList =
+  Array<OtbDeviceStatistics>;
+export const ListOverTheBoxStatisticsResponseBodyList = /*@__PURE__*/ S.Array(
+  OtbDeviceStatistics,
+) as any as S.Schema<ListOverTheBoxStatisticsResponseBodyList>;
+
+export type ListOverTheBoxStatisticsResponse =
+  ListOverTheBoxStatisticsResponseBodyList;
+export const ListOverTheBoxStatisticsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListOverTheBoxStatisticsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListOverTheBoxStatisticsResponse",
+}) as any as S.Schema<ListOverTheBoxStatisticsResponse>;
+
+export interface ListOverTheBoxTasksRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+  /** Filter the value of name property (=) */
+  name?: string;
+  /** Filter the value of status property (=) */
+  status?: OverTheBoxTaskStatusEnum | (string & {});
+}
+export const ListOverTheBoxTasksRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    name: S.optional(S.String.pipe(T.Query())),
+    status: S.optional(OverTheBoxTaskStatusEnum.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/overTheBox/{serviceName}/tasks",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListOverTheBoxTasksRequest",
+}) as any as S.Schema<ListOverTheBoxTasksRequest>;
+
+export type ListOverTheBoxTasksResponseBodyList = Array<string>;
+export const ListOverTheBoxTasksResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListOverTheBoxTasksResponseBodyList>;
+
+export type ListOverTheBoxTasksResponse = ListOverTheBoxTasksResponseBodyList;
+export const ListOverTheBoxTasksResponse = /*@__PURE__*/ S.suspend(() =>
+  ListOverTheBoxTasksResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListOverTheBoxTasksResponse",
+}) as any as S.Schema<ListOverTheBoxTasksResponse>;
+
+export interface PutOverTheBoxRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+  /** Enable device auto upgrade */
+  autoUpgrade?: boolean;
+  /** Editable field for customer */
+  customerDescription?: string | null;
+  /** Release channel of the service */
+  releaseChannel?: string;
+}
+export const PutOverTheBoxRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    autoUpgrade: S.optional(S.Boolean),
+    customerDescription: S.optional(S.NullOr(S.String)),
+    releaseChannel: S.optional(S.String),
+  }).pipe(
+    T.Http({ method: "PUT", uri: "/overTheBox/{serviceName}", code: 200 }),
+  ),
+).annotate({
+  identifier: "PutOverTheBoxRequest",
+}) as any as S.Schema<PutOverTheBoxRequest>;
+
+export interface PutOverTheBoxResponse {}
+export const PutOverTheBoxResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutOverTheBoxResponse",
+}) as any as S.Schema<PutOverTheBoxResponse>;
+
+export interface PutOverTheBoxAutoMTURequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+  /** Enable or disable autoMTU */
+  mtuAuto: OverTheBoxAvailableStatusEnum | (string & {});
+}
+export const PutOverTheBoxAutoMTURequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    mtuAuto: OverTheBoxAvailableStatusEnum,
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/overTheBox/{serviceName}/autoMTU",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutOverTheBoxAutoMTURequest",
+}) as any as S.Schema<PutOverTheBoxAutoMTURequest>;
+
+export interface PutOverTheBoxAutoMTUResponse {}
+export const PutOverTheBoxAutoMTUResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutOverTheBoxAutoMTUResponse",
+}) as any as S.Schema<PutOverTheBoxAutoMTUResponse>;
+
+export interface PutOverTheBoxIpv6Request {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+  /** Enabled/disabled IPv6 */
+  enabled: boolean;
+}
+export const PutOverTheBoxIpv6Request = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    enabled: S.Boolean,
+  }).pipe(
+    T.Http({ method: "PUT", uri: "/overTheBox/{serviceName}/ipv6", code: 200 }),
+  ),
+).annotate({
+  identifier: "PutOverTheBoxIpv6Request",
+}) as any as S.Schema<PutOverTheBoxIpv6Request>;
+
+export interface PutOverTheBoxServiceInfosRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+  /** Way of handling the renew */
+  renew?: ServiceRenewType | null;
+}
+export const PutOverTheBoxServiceInfosRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    renew: S.optional(S.NullOr(ServiceRenewType)),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/overTheBox/{serviceName}/serviceInfos",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutOverTheBoxServiceInfosRequest",
+}) as any as S.Schema<PutOverTheBoxServiceInfosRequest>;
+
+export interface PutOverTheBoxServiceInfosResponse {}
+export const PutOverTheBoxServiceInfosResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutOverTheBoxServiceInfosResponse",
+}) as any as S.Schema<PutOverTheBoxServiceInfosResponse>;
+
+export interface RestoreOverTheBoxDeviceBackupRequest {
+  /** The internal name of your overTheBox offer */
+  serviceName: string;
+  /** The id of the backup to restore */
+  backupId: string;
+}
+export const RestoreOverTheBoxDeviceBackupRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      backupId: S.String,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/overTheBox/{serviceName}/device/restoreBackup",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "RestoreOverTheBoxDeviceBackupRequest",
+}) as any as S.Schema<RestoreOverTheBoxDeviceBackupRequest>;
+
+export type RestoreOverTheBoxDeviceBackupResponseBodyList =
+  Array<OverTheBoxDeviceAction>;
+export const RestoreOverTheBoxDeviceBackupResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    OverTheBoxDeviceAction,
+  ) as any as S.Schema<RestoreOverTheBoxDeviceBackupResponseBodyList>;
+
+export type RestoreOverTheBoxDeviceBackupResponse =
+  RestoreOverTheBoxDeviceBackupResponseBodyList;
+export const RestoreOverTheBoxDeviceBackupResponse = /*@__PURE__*/ S.suspend(
+  () => RestoreOverTheBoxDeviceBackupResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "RestoreOverTheBoxDeviceBackupResponse",
+}) as any as S.Schema<RestoreOverTheBoxDeviceBackupResponse>;
+
+export type AuthorizeOverTheBoxRemoteAccessError = OvhOpError;
+/** Authorize the remote access */
+export const authorizeOverTheBoxRemoteAccess: API.OperationMethod<
+  AuthorizeOverTheBoxRemoteAccessRequest,
+  AuthorizeOverTheBoxRemoteAccessResponse,
+  AuthorizeOverTheBoxRemoteAccessError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AuthorizeOverTheBoxRemoteAccessRequest,
+  output: AuthorizeOverTheBoxRemoteAccessResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CancelOverTheBoxResiliationError = OvhOpError;
+/** Cancel the resiliation of the Service */
+export const cancelOverTheBoxResiliation: API.OperationMethod<
+  CancelOverTheBoxResiliationRequest,
+  CancelOverTheBoxResiliationResponse,
+  CancelOverTheBoxResiliationError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CancelOverTheBoxResiliationRequest,
+  output: CancelOverTheBoxResiliationResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateOverTheBoxChangeContactError = OvhOpError;
+/** Launch a contact change procedure */
+export const createOverTheBoxChangeContact: API.OperationMethod<
+  CreateOverTheBoxChangeContactRequest,
+  CreateOverTheBoxChangeContactResponse,
+  CreateOverTheBoxChangeContactError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateOverTheBoxChangeContactRequest,
+  output: CreateOverTheBoxChangeContactResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateOverTheBoxDeviceError = OvhOpError;
+/** Get the list of devices connected from the same IP address */
+export const createOverTheBoxDevice: API.OperationMethod<
+  CreateOverTheBoxDeviceRequest,
+  CreateOverTheBoxDeviceResponse,
+  CreateOverTheBoxDeviceError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateOverTheBoxDeviceRequest,
+  output: CreateOverTheBoxDeviceResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateOverTheBoxDeviceActionError = OvhOpError;
+/** Create a device action on the device */
+export const createOverTheBoxDeviceAction: API.OperationMethod<
+  CreateOverTheBoxDeviceActionRequest,
+  OverTheBoxDeviceAction,
+  CreateOverTheBoxDeviceActionError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateOverTheBoxDeviceActionRequest,
+  output: OverTheBoxDeviceAction,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateOverTheBoxDeviceBackupError = OvhOpError;
+/** Create an action to generate a backup */
+export const createOverTheBoxDeviceBackup: API.OperationMethod<
+  CreateOverTheBoxDeviceBackupRequest,
+  OverTheBoxDeviceAction,
+  CreateOverTheBoxDeviceBackupError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateOverTheBoxDeviceBackupRequest,
+  output: OverTheBoxDeviceAction,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateOverTheBoxDeviceLogError = OvhOpError;
+/** Generate a temporary url to retrieve device logs */
+export const createOverTheBoxDeviceLog: API.OperationMethod<
+  CreateOverTheBoxDeviceLogRequest,
+  OverTheBoxTemporaryLogsLink,
+  CreateOverTheBoxDeviceLogError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateOverTheBoxDeviceLogRequest,
+  output: OverTheBoxTemporaryLogsLink,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateOverTheBoxLinkDeviceError = OvhOpError;
+/** Link a device to this service */
+export const createOverTheBoxLinkDevice: API.OperationMethod<
+  CreateOverTheBoxLinkDeviceRequest,
+  CreateOverTheBoxLinkDeviceResponse,
+  CreateOverTheBoxLinkDeviceError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateOverTheBoxLinkDeviceRequest,
+  output: CreateOverTheBoxLinkDeviceResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateOverTheBoxLinkHardwareError = OvhOpError;
+/** Link an available hardware to this service */
+export const createOverTheBoxLinkHardware: API.OperationMethod<
+  CreateOverTheBoxLinkHardwareRequest,
+  CreateOverTheBoxLinkHardwareResponse,
+  CreateOverTheBoxLinkHardwareError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateOverTheBoxLinkHardwareRequest,
+  output: CreateOverTheBoxLinkHardwareResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateOverTheBoxMigrationChangeOfferError = OvhOpError;
+/** Migrate to the selected overTheBox offer */
+export const createOverTheBoxMigrationChangeOffer: API.OperationMethod<
+  CreateOverTheBoxMigrationChangeOfferRequest,
+  OverTheBoxOrderMigration,
+  CreateOverTheBoxMigrationChangeOfferError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateOverTheBoxMigrationChangeOfferRequest,
+  output: OverTheBoxOrderMigration,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateOverTheBoxRemoteAccessError = OvhOpError;
+/** Create a new remote access for the service */
+export const createOverTheBoxRemoteAccess: API.OperationMethod<
+  CreateOverTheBoxRemoteAccessRequest,
+  OverTheBoxRemoteAccess,
+  CreateOverTheBoxRemoteAccessError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateOverTheBoxRemoteAccessRequest,
+  output: OverTheBoxRemoteAccess,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteOverTheBoxError = OvhOpError;
+/** Resiliate a service */
+export const deleteOverTheBox: API.OperationMethod<
+  DeleteOverTheBoxRequest,
+  DeleteOverTheBoxResponse,
+  DeleteOverTheBoxError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteOverTheBoxRequest,
+  output: DeleteOverTheBoxResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteOverTheBoxBackupError = OvhOpError;
+/** Delete a backup */
+export const deleteOverTheBoxBackup: API.OperationMethod<
+  DeleteOverTheBoxBackupRequest,
+  DeleteOverTheBoxBackupResponse,
+  DeleteOverTheBoxBackupError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteOverTheBoxBackupRequest,
+  output: DeleteOverTheBoxBackupResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteOverTheBoxDeviceError = OvhOpError;
+/** Unlink a device from a service */
+export const deleteOverTheBoxDevice: API.OperationMethod<
+  DeleteOverTheBoxDeviceRequest,
+  DeleteOverTheBoxDeviceResponse,
+  DeleteOverTheBoxDeviceError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteOverTheBoxDeviceRequest,
+  output: DeleteOverTheBoxDeviceResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteOverTheBoxRemoteAccessError = OvhOpError;
+/** Delete a remote access */
+export const deleteOverTheBoxRemoteAccess: API.OperationMethod<
+  DeleteOverTheBoxRemoteAccessRequest,
+  DeleteOverTheBoxRemoteAccessResponse,
+  DeleteOverTheBoxRemoteAccessError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteOverTheBoxRemoteAccessRequest,
+  output: DeleteOverTheBoxRemoteAccessResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOverTheBoxError = OvhOpError;
+/** Get this object properties */
+export const getOverTheBox: API.OperationMethod<
+  GetOverTheBoxRequest,
+  OverTheBoxServiceWithIAM,
+  GetOverTheBoxError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOverTheBoxRequest,
+  output: OverTheBoxServiceWithIAM,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOverTheBoxBackupError = OvhOpError;
+/** Get this object properties */
+export const getOverTheBoxBackup: API.OperationMethod<
+  GetOverTheBoxBackupRequest,
+  OverTheBoxBackup,
+  GetOverTheBoxBackupError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOverTheBoxBackupRequest,
+  output: OverTheBoxBackup,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOverTheBoxDeviceError = OvhOpError;
+/** Get this object properties */
+export const getOverTheBoxDevice: API.OperationMethod<
+  GetOverTheBoxDeviceRequest,
+  OverTheBoxDevice,
+  GetOverTheBoxDeviceError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOverTheBoxDeviceRequest,
+  output: OverTheBoxDevice,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOverTheBoxDeviceActionError = OvhOpError;
+/** Get this object properties */
+export const getOverTheBoxDeviceAction: API.OperationMethod<
+  GetOverTheBoxDeviceActionRequest,
+  OverTheBoxDeviceAction,
+  GetOverTheBoxDeviceActionError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOverTheBoxDeviceActionRequest,
+  output: OverTheBoxDeviceAction,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOverTheBoxDeviceHardwareError = OvhOpError;
+/** Get this object properties */
+export const getOverTheBoxDeviceHardware: API.OperationMethod<
+  GetOverTheBoxDeviceHardwareRequest,
+  OverTheBoxHardware,
+  GetOverTheBoxDeviceHardwareError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOverTheBoxDeviceHardwareRequest,
+  output: OverTheBoxHardware,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOverTheBoxHardwareError = OvhOpError;
+/** Get this object properties */
+export const getOverTheBoxHardware: API.OperationMethod<
+  GetOverTheBoxHardwareRequest,
+  OverTheBoxHardwareWithIAM,
+  GetOverTheBoxHardwareError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOverTheBoxHardwareRequest,
+  output: OverTheBoxHardwareWithIAM,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOverTheBoxIpsError = OvhOpError;
+/** Get details IP assigned to an OverTheBox service */
+export const getOverTheBoxIps: API.OperationMethod<
+  GetOverTheBoxIpsRequest,
+  OtbServiceIp,
+  GetOverTheBoxIpsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOverTheBoxIpsRequest,
+  output: OtbServiceIp,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOverTheBoxRemoteAccessError = OvhOpError;
+/** Get this object properties */
+export const getOverTheBoxRemoteAccess: API.OperationMethod<
+  GetOverTheBoxRemoteAccessRequest,
+  OverTheBoxRemoteAccess,
+  GetOverTheBoxRemoteAccessError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOverTheBoxRemoteAccessRequest,
+  output: OverTheBoxRemoteAccess,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOverTheBoxServiceInfosError = OvhOpError;
+/** Get service information */
+export const getOverTheBoxServiceInfos: API.OperationMethod<
+  GetOverTheBoxServiceInfosRequest,
+  ServicesService,
+  GetOverTheBoxServiceInfosError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOverTheBoxServiceInfosRequest,
+  output: ServicesService,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOverTheBoxTaskError = OvhOpError;
+/** Get this object properties */
+export const getOverTheBoxTask: API.OperationMethod<
+  GetOverTheBoxTaskRequest,
+  OverTheBoxTask,
+  GetOverTheBoxTaskError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOverTheBoxTaskRequest,
+  output: OverTheBoxTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOverTheBoxError = OvhOpError;
+/** List available services */
+export const listOverTheBox: API.OperationMethod<
+  ListOverTheBoxRequest,
+  ListOverTheBoxResponse,
+  ListOverTheBoxError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOverTheBoxRequest,
+  output: ListOverTheBoxResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOverTheBoxAvailableOffersError = OvhOpError;
+/** List the available offers for the new call */
+export const listOverTheBoxAvailableOffers: API.OperationMethod<
+  ListOverTheBoxAvailableOffersRequest,
+  ListOverTheBoxAvailableOffersResponse,
+  ListOverTheBoxAvailableOffersError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOverTheBoxAvailableOffersRequest,
+  output: ListOverTheBoxAvailableOffersResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOverTheBoxAvailableReleaseChannelsError = OvhOpError;
+/** List available release channels for this service */
+export const listOverTheBoxAvailableReleaseChannels: API.OperationMethod<
+  ListOverTheBoxAvailableReleaseChannelsRequest,
+  ListOverTheBoxAvailableReleaseChannelsResponse,
+  ListOverTheBoxAvailableReleaseChannelsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOverTheBoxAvailableReleaseChannelsRequest,
+  output: ListOverTheBoxAvailableReleaseChannelsResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOverTheBoxBackupsError = OvhOpError;
+/** List of backups for this service */
+export const listOverTheBoxBackups: API.OperationMethod<
+  ListOverTheBoxBackupsRequest,
+  ListOverTheBoxBackupsResponse,
+  ListOverTheBoxBackupsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOverTheBoxBackupsRequest,
+  output: ListOverTheBoxBackupsResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOverTheBoxDeviceActionsError = OvhOpError;
+/** List of actions scheduled for this device */
+export const listOverTheBoxDeviceActions: API.OperationMethod<
+  ListOverTheBoxDeviceActionsRequest,
+  ListOverTheBoxDeviceActionsResponse,
+  ListOverTheBoxDeviceActionsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOverTheBoxDeviceActionsRequest,
+  output: ListOverTheBoxDeviceActionsResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOverTheBoxDeviceAvailableActionsError = OvhOpError;
+/** List the available device actions */
+export const listOverTheBoxDeviceAvailableActions: API.OperationMethod<
+  ListOverTheBoxDeviceAvailableActionsRequest,
+  ListOverTheBoxDeviceAvailableActionsResponse,
+  ListOverTheBoxDeviceAvailableActionsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOverTheBoxDeviceAvailableActionsRequest,
+  output: ListOverTheBoxDeviceAvailableActionsResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOverTheBoxHardwareError = OvhOpError;
+/** List available services */
+export const listOverTheBoxHardware: API.OperationMethod<
+  ListOverTheBoxHardwareRequest,
+  ListOverTheBoxHardwareResponse,
+  ListOverTheBoxHardwareError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOverTheBoxHardwareRequest,
+  output: ListOverTheBoxHardwareResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOverTheBoxHardwareAvailableError = OvhOpError;
+/** List hardware that can be linked to a service */
+export const listOverTheBoxHardwareAvailable: API.OperationMethod<
+  ListOverTheBoxHardwareAvailableRequest,
+  ListOverTheBoxHardwareAvailableResponse,
+  ListOverTheBoxHardwareAvailableError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOverTheBoxHardwareAvailableRequest,
+  output: ListOverTheBoxHardwareAvailableResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOverTheBoxIpsError = OvhOpError;
+/** List IP assigned to an OverTheBox service */
+export const listOverTheBoxIps: API.OperationMethod<
+  ListOverTheBoxIpsRequest,
+  ListOverTheBoxIpsResponse,
+  ListOverTheBoxIpsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOverTheBoxIpsRequest,
+  output: ListOverTheBoxIpsResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOverTheBoxMigrationOffersError = OvhOpError;
+/** List all available offers one can migrate to */
+export const listOverTheBoxMigrationOffers: API.OperationMethod<
+  ListOverTheBoxMigrationOffersRequest,
+  ListOverTheBoxMigrationOffersResponse,
+  ListOverTheBoxMigrationOffersError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOverTheBoxMigrationOffersRequest,
+  output: ListOverTheBoxMigrationOffersResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOverTheBoxRemoteAccessesError = OvhOpError;
+/** List of remote accesses for the service */
+export const listOverTheBoxRemoteAccesses: API.OperationMethod<
+  ListOverTheBoxRemoteAccessesRequest,
+  ListOverTheBoxRemoteAccessesResponse,
+  ListOverTheBoxRemoteAccessesError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOverTheBoxRemoteAccessesRequest,
+  output: ListOverTheBoxRemoteAccessesResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOverTheBoxStatisticsError = OvhOpError;
+/** Get statistics for an OTB device */
+export const listOverTheBoxStatistics: API.OperationMethod<
+  ListOverTheBoxStatisticsRequest,
+  ListOverTheBoxStatisticsResponse,
+  ListOverTheBoxStatisticsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOverTheBoxStatisticsRequest,
+  output: ListOverTheBoxStatisticsResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOverTheBoxTasksError = OvhOpError;
+/** List of tasks scheduled for this service */
+export const listOverTheBoxTasks: API.OperationMethod<
+  ListOverTheBoxTasksRequest,
+  ListOverTheBoxTasksResponse,
+  ListOverTheBoxTasksError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOverTheBoxTasksRequest,
+  output: ListOverTheBoxTasksResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutOverTheBoxError = OvhOpError;
+/** Alter this object properties */
+export const putOverTheBox: API.OperationMethod<
+  PutOverTheBoxRequest,
+  PutOverTheBoxResponse,
+  PutOverTheBoxError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutOverTheBoxRequest,
+  output: PutOverTheBoxResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutOverTheBoxAutoMTUError = OvhOpError;
+/** Change the value of autoMTU */
+export const putOverTheBoxAutoMTU: API.OperationMethod<
+  PutOverTheBoxAutoMTURequest,
+  PutOverTheBoxAutoMTUResponse,
+  PutOverTheBoxAutoMTUError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutOverTheBoxAutoMTURequest,
+  output: PutOverTheBoxAutoMTUResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutOverTheBoxIpv6Error = OvhOpError;
+/** Change the status of IPv6 on this service */
+export const putOverTheBoxIpv6: API.OperationMethod<
+  PutOverTheBoxIpv6Request,
+  OverTheBoxTask,
+  PutOverTheBoxIpv6Error,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutOverTheBoxIpv6Request,
+  output: OverTheBoxTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutOverTheBoxServiceInfosError = OvhOpError;
+/** Update service information */
+export const putOverTheBoxServiceInfos: API.OperationMethod<
+  PutOverTheBoxServiceInfosRequest,
+  PutOverTheBoxServiceInfosResponse,
+  PutOverTheBoxServiceInfosError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutOverTheBoxServiceInfosRequest,
+  output: PutOverTheBoxServiceInfosResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RestoreOverTheBoxDeviceBackupError = OvhOpError;
+/** Create a group of actions to restore a given backup */
+export const restoreOverTheBoxDeviceBackup: API.OperationMethod<
+  RestoreOverTheBoxDeviceBackupRequest,
+  RestoreOverTheBoxDeviceBackupResponse,
+  RestoreOverTheBoxDeviceBackupError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RestoreOverTheBoxDeviceBackupRequest,
+  output: RestoreOverTheBoxDeviceBackupResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));