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

package/src/services/vrack.ts

@@ -0,0 +1,3730 @@
+// 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 ConfirmVrackTerminationRequest {
+  /** The internal name of your vrack */
+  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 ConfirmVrackTerminationRequest = /*@__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: "/vrack/{serviceName}/confirmTermination",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ConfirmVrackTerminationRequest",
+}) as any as S.Schema<ConfirmVrackTerminationRequest>;
+
+export type ConfirmVrackTerminationResponse = string;
+export const ConfirmVrackTerminationResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ConfirmVrackTerminationResponse",
+}) as any as S.Schema<ConfirmVrackTerminationResponse>;
+
+export interface CreateVrackChangeContactRequest {
+  /** The internal name of your vrack */
+  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 CreateVrackChangeContactRequest = /*@__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: "/vrack/{serviceName}/changeContact",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateVrackChangeContactRequest",
+}) as any as S.Schema<CreateVrackChangeContactRequest>;
+
+export type CreateVrackChangeContactResponseBodyList = Array<number>;
+export const CreateVrackChangeContactResponseBodyList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<CreateVrackChangeContactResponseBodyList>;
+
+export type CreateVrackChangeContactResponse =
+  CreateVrackChangeContactResponseBodyList;
+export const CreateVrackChangeContactResponse = /*@__PURE__*/ S.suspend(() =>
+  CreateVrackChangeContactResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateVrackChangeContactResponse",
+}) as any as S.Schema<CreateVrackChangeContactResponse>;
+
+export interface CreateVrackCloudProjectRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** publicCloud project to add */
+  project: string;
+}
+export const CreateVrackCloudProjectRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    project: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/vrack/{serviceName}/cloudProject",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateVrackCloudProjectRequest",
+}) as any as S.Schema<CreateVrackCloudProjectRequest>;
+
+/** All states a vRack Task can be in */
+export type VrackTaskStatusEnum =
+  | "cancelled"
+  | "doing"
+  | "done"
+  | "init"
+  | "todo";
+export const VrackTaskStatusEnum = /*@__PURE__*/ S.String;
+
+/** vrack tasks */
+export interface VrackTask {
+  function?: string;
+  id?: number;
+  lastUpdate?: string | null;
+  orderId?: number | null;
+  serviceName?: string | null;
+  /** Task status */
+  status?: VrackTaskStatusEnum;
+  targetDomain?: string | null;
+  todoDate?: string | null;
+}
+export const VrackTask = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    function: S.optional(S.String),
+    id: S.optional(S.Number),
+    lastUpdate: S.optional(S.NullOr(S.String)),
+    orderId: S.optional(S.NullOr(S.Number)),
+    serviceName: S.optional(S.NullOr(S.String)),
+    status: S.optional(VrackTaskStatusEnum),
+    targetDomain: S.optional(S.NullOr(S.String)),
+    todoDate: S.optional(S.NullOr(S.String)),
+  }),
+).annotate({ identifier: "VrackTask" }) as any as S.Schema<VrackTask>;
+
+export interface CreateVrackDedicatedCloudRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  dedicatedCloud: string;
+}
+export const CreateVrackDedicatedCloudRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    dedicatedCloud: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/vrack/{serviceName}/dedicatedCloud",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateVrackDedicatedCloudRequest",
+}) as any as S.Schema<CreateVrackDedicatedCloudRequest>;
+
+export interface CreateVrackDedicatedConnectRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Hostname of the network device where the dedicatedConnect link is connected to */
+  entryPointSwitch: string;
+  /** A name for the dedicatedConnect link */
+  name: string;
+  /** Vlan id of the dedicated link on OVH's G5 router */
+  vlanId: number;
+}
+export const CreateVrackDedicatedConnectRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    entryPointSwitch: S.String,
+    name: S.String,
+    vlanId: S.Number,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/vrack/{serviceName}/dedicatedConnect",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateVrackDedicatedConnectRequest",
+}) as any as S.Schema<CreateVrackDedicatedConnectRequest>;
+
+export interface CreateVrackDedicatedServerRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Dedicated server to add */
+  dedicatedServer: string;
+}
+export const CreateVrackDedicatedServerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    dedicatedServer: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/vrack/{serviceName}/dedicatedServer",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateVrackDedicatedServerRequest",
+}) as any as S.Schema<CreateVrackDedicatedServerRequest>;
+
+export interface CreateVrackDedicatedServerInterfaceRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Dedicated server interface to add */
+  dedicatedServerInterface: string;
+}
+export const CreateVrackDedicatedServerInterfaceRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      dedicatedServerInterface: S.String,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/vrack/{serviceName}/dedicatedServerInterface",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateVrackDedicatedServerInterfaceRequest",
+  }) as any as S.Schema<CreateVrackDedicatedServerInterfaceRequest>;
+
+export interface CreateVrackIpRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Your IP block */
+  block: string;
+  /** Choose the region in which to route the block */
+  region?: string;
+}
+export const CreateVrackIpRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    block: S.String,
+    region: S.optional(S.String),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/vrack/{serviceName}/ip", code: 200 }),
+  ),
+).annotate({
+  identifier: "CreateVrackIpRequest",
+}) as any as S.Schema<CreateVrackIpRequest>;
+
+export interface CreateVrackIpLoadbalancingRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Your ipLoadbalancing */
+  ipLoadbalancing: string;
+}
+export const CreateVrackIpLoadbalancingRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    ipLoadbalancing: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/vrack/{serviceName}/ipLoadbalancing",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateVrackIpLoadbalancingRequest",
+}) as any as S.Schema<CreateVrackIpLoadbalancingRequest>;
+
+export interface CreateVrackIpv6Request {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Your IP v6 block */
+  block: string;
+}
+export const CreateVrackIpv6Request = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    block: S.String,
+  }).pipe(
+    T.Http({ method: "POST", uri: "/vrack/{serviceName}/ipv6", code: 200 }),
+  ),
+).annotate({
+  identifier: "CreateVrackIpv6Request",
+}) as any as S.Schema<CreateVrackIpv6Request>;
+
+export interface CreateVrackIpv6RoutedSubrangeRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Your IP v6 block */
+  ipv6: string;
+  /** nexthop to configure for your routed subrange (must be part of bridged subrange) */
+  nexthop: string;
+  /** subrange to route into your vrack */
+  routedSubrange: string;
+}
+export const CreateVrackIpv6RoutedSubrangeRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      ipv6: S.String.pipe(T.Label()),
+      nexthop: S.String,
+      routedSubrange: S.String,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/vrack/{serviceName}/ipv6/{ipv6}/routedSubrange",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "CreateVrackIpv6RoutedSubrangeRequest",
+}) as any as S.Schema<CreateVrackIpv6RoutedSubrangeRequest>;
+
+export interface CreateVrackLegacyVrackRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  legacyVrack: string;
+}
+export const CreateVrackLegacyVrackRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    legacyVrack: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/vrack/{serviceName}/legacyVrack",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateVrackLegacyVrackRequest",
+}) as any as S.Schema<CreateVrackLegacyVrackRequest>;
+
+export interface CreateVrackOvhCloudConnectRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** ovhCloudConnect service name */
+  ovhCloudConnect: string;
+}
+export const CreateVrackOvhCloudConnectRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    ovhCloudConnect: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/vrack/{serviceName}/ovhCloudConnect",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateVrackOvhCloudConnectRequest",
+}) as any as S.Schema<CreateVrackOvhCloudConnectRequest>;
+
+export interface CreateVrackVmwareCloudDirectorVirtualDataCenterRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** vmwareCloudDirectorVirtualDataCenter service name */
+  vmwareCloudDirectorVirtualDataCenter: string;
+}
+export const CreateVrackVmwareCloudDirectorVirtualDataCenterRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      vmwareCloudDirectorVirtualDataCenter: S.String,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/vrack/{serviceName}/vmwareCloudDirectorVirtualDataCenter",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateVrackVmwareCloudDirectorVirtualDataCenterRequest",
+  }) as any as S.Schema<CreateVrackVmwareCloudDirectorVirtualDataCenterRequest>;
+
+export interface CreateVrackVrackServiceRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** vrackServices service name */
+  vrackServices: string;
+}
+export const CreateVrackVrackServiceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    vrackServices: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/vrack/{serviceName}/vrackServices",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateVrackVrackServiceRequest",
+}) as any as S.Schema<CreateVrackVrackServiceRequest>;
+
+export interface DeleteVrackCloudProjectRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** publicCloud project */
+  project: string;
+}
+export const DeleteVrackCloudProjectRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    project: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/vrack/{serviceName}/cloudProject/{project}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteVrackCloudProjectRequest",
+}) as any as S.Schema<DeleteVrackCloudProjectRequest>;
+
+export interface DeleteVrackDedicatedCloudRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** your dedicated cloud service */
+  dedicatedCloud: string;
+}
+export const DeleteVrackDedicatedCloudRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    dedicatedCloud: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/vrack/{serviceName}/dedicatedCloud/{dedicatedCloud}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteVrackDedicatedCloudRequest",
+}) as any as S.Schema<DeleteVrackDedicatedCloudRequest>;
+
+export interface DeleteVrackDedicatedConnectRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** A name for your dedicatedConnect link */
+  name: string;
+}
+export const DeleteVrackDedicatedConnectRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    name: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/vrack/{serviceName}/dedicatedConnect/{name}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteVrackDedicatedConnectRequest",
+}) as any as S.Schema<DeleteVrackDedicatedConnectRequest>;
+
+export interface DeleteVrackDedicatedServerRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Dedicated Server */
+  dedicatedServer: string;
+}
+export const DeleteVrackDedicatedServerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    dedicatedServer: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/vrack/{serviceName}/dedicatedServer/{dedicatedServer}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteVrackDedicatedServerRequest",
+}) as any as S.Schema<DeleteVrackDedicatedServerRequest>;
+
+export interface DeleteVrackDedicatedServerInterfaceRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Dedicated Server Interface */
+  dedicatedServerInterface: string;
+}
+export const DeleteVrackDedicatedServerInterfaceRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      dedicatedServerInterface: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/vrack/{serviceName}/dedicatedServerInterface/{dedicatedServerInterface}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "DeleteVrackDedicatedServerInterfaceRequest",
+  }) as any as S.Schema<DeleteVrackDedicatedServerInterfaceRequest>;
+
+export interface DeleteVrackIpRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Your IP block */
+  ip: string;
+}
+export const DeleteVrackIpRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    ip: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/vrack/{serviceName}/ip/{ip}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteVrackIpRequest",
+}) as any as S.Schema<DeleteVrackIpRequest>;
+
+export interface DeleteVrackIpLoadbalancingRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Your ipLoadbalancing */
+  ipLoadbalancing: string;
+}
+export const DeleteVrackIpLoadbalancingRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    ipLoadbalancing: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/vrack/{serviceName}/ipLoadbalancing/{ipLoadbalancing}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteVrackIpLoadbalancingRequest",
+}) as any as S.Schema<DeleteVrackIpLoadbalancingRequest>;
+
+export interface DeleteVrackIpv6Request {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Your IP v6 block */
+  ipv6: string;
+}
+export const DeleteVrackIpv6Request = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    ipv6: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/vrack/{serviceName}/ipv6/{ipv6}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteVrackIpv6Request",
+}) as any as S.Schema<DeleteVrackIpv6Request>;
+
+export interface DeleteVrackIpv6RoutedSubrangeRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Your IP v6 block */
+  ipv6: string;
+  /** subrange routed into your vrack */
+  routedSubrange: string;
+}
+export const DeleteVrackIpv6RoutedSubrangeRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      ipv6: S.String.pipe(T.Label()),
+      routedSubrange: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/vrack/{serviceName}/ipv6/{ipv6}/routedSubrange/{routedSubrange}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "DeleteVrackIpv6RoutedSubrangeRequest",
+}) as any as S.Schema<DeleteVrackIpv6RoutedSubrangeRequest>;
+
+export interface DeleteVrackLegacyVrackRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** your legacy vrack service */
+  legacyVrack: string;
+}
+export const DeleteVrackLegacyVrackRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    legacyVrack: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/vrack/{serviceName}/legacyVrack/{legacyVrack}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteVrackLegacyVrackRequest",
+}) as any as S.Schema<DeleteVrackLegacyVrackRequest>;
+
+export interface DeleteVrackOvhCloudConnectRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** ovhCloudConnect service name */
+  ovhCloudConnect: string;
+}
+export const DeleteVrackOvhCloudConnectRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    ovhCloudConnect: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/vrack/{serviceName}/ovhCloudConnect/{ovhCloudConnect}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteVrackOvhCloudConnectRequest",
+}) as any as S.Schema<DeleteVrackOvhCloudConnectRequest>;
+
+export interface DeleteVrackVmwareCloudDirectorVirtualDataCenterRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** vmwareCloudDirectorVirtualDataCenter service name */
+  vmwareCloudDirectorVirtualDataCenter: string;
+}
+export const DeleteVrackVmwareCloudDirectorVirtualDataCenterRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      vmwareCloudDirectorVirtualDataCenter: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/vrack/{serviceName}/vmwareCloudDirectorVirtualDataCenter/{vmwareCloudDirectorVirtualDataCenter}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "DeleteVrackVmwareCloudDirectorVirtualDataCenterRequest",
+  }) as any as S.Schema<DeleteVrackVmwareCloudDirectorVirtualDataCenterRequest>;
+
+export interface DeleteVrackVrackServiceRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** vrackServices service name */
+  vrackServices: string;
+}
+export const DeleteVrackVrackServiceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    vrackServices: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/vrack/{serviceName}/vrackServices/{vrackServices}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteVrackVrackServiceRequest",
+}) as any as S.Schema<DeleteVrackVrackServiceRequest>;
+
+export interface GetVrackRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+}
+export const GetVrackRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/vrack/{serviceName}", code: 200 })),
+).annotate({
+  identifier: "GetVrackRequest",
+}) as any as S.Schema<GetVrackRequest>;
+
+/** 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>;
+
+/** vrack */
+export interface VrackVrackWithIAM {
+  /** Description of the vRack */
+  description?: string;
+  /** IAM resource metadata */
+  iam?: IamResourceMetadata | null;
+  /** Name of the vRack */
+  name?: string;
+  /** Service name of your vRack on OVHcloud */
+  serviceName?: string;
+}
+export const VrackVrackWithIAM = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    description: S.optional(S.String),
+    iam: S.optional(S.NullOr(IamResourceMetadata)),
+    name: S.optional(S.String),
+    serviceName: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "VrackVrackWithIAM",
+}) as any as S.Schema<VrackVrackWithIAM>;
+
+export interface GetVrackCloudProjectRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** publicCloud project */
+  project: string;
+}
+export const GetVrackCloudProjectRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    project: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/cloudProject/{project}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetVrackCloudProjectRequest",
+}) as any as S.Schema<GetVrackCloudProjectRequest>;
+
+/** PublicCloud project in vrack */
+export interface VrackCloudProject {
+  /** publicCloud project */
+  project?: string;
+  /** vrack name */
+  vrack?: string;
+}
+export const VrackCloudProject = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    project: S.optional(S.String),
+    vrack: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "VrackCloudProject",
+}) as any as S.Schema<VrackCloudProject>;
+
+export interface GetVrackDedicatedCloudRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** your dedicated cloud service */
+  dedicatedCloud: string;
+}
+export const GetVrackDedicatedCloudRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    dedicatedCloud: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/dedicatedCloud/{dedicatedCloud}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetVrackDedicatedCloudRequest",
+}) as any as S.Schema<GetVrackDedicatedCloudRequest>;
+
+/** VMware on OVHcloud vRack link */
+export interface VrackDedicatedCloud {
+  /** your dedicated cloud service */
+  dedicatedCloud?: string;
+  /** Dedicated cloud vlanId used */
+  vlanId?: number | null;
+  /** vrack name */
+  vrack?: string;
+}
+export const VrackDedicatedCloud = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    dedicatedCloud: S.optional(S.String),
+    vlanId: S.optional(S.NullOr(S.Number)),
+    vrack: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "VrackDedicatedCloud",
+}) as any as S.Schema<VrackDedicatedCloud>;
+
+export interface GetVrackDedicatedCloudDatacenterRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Your dedicatedCloud datacenter name */
+  datacenter: string;
+}
+export const GetVrackDedicatedCloudDatacenterRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      datacenter: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/vrack/{serviceName}/dedicatedCloudDatacenter/{datacenter}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetVrackDedicatedCloudDatacenterRequest",
+}) as any as S.Schema<GetVrackDedicatedCloudDatacenterRequest>;
+
+/** vrack datacenter interface */
+export interface VrackPccDatacenter {
+  /** Your dedicatedCloud datacenter name */
+  datacenter?: string;
+  /** Your dedicatedCloud name */
+  dedicatedCloud?: string;
+  /** vrack name */
+  vrack?: string;
+}
+export const VrackPccDatacenter = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    datacenter: S.optional(S.String),
+    dedicatedCloud: S.optional(S.String),
+    vrack: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "VrackPccDatacenter",
+}) as any as S.Schema<VrackPccDatacenter>;
+
+export interface GetVrackDedicatedConnectRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** A name for your dedicatedConnect link */
+  name: string;
+}
+export const GetVrackDedicatedConnectRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    name: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/dedicatedConnect/{name}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetVrackDedicatedConnectRequest",
+}) as any as S.Schema<GetVrackDedicatedConnectRequest>;
+
+/** vrack dedicated connect interface */
+export interface VrackDedicatedConnect {
+  /** A name for your dedicatedConnect link */
+  name?: string;
+}
+export const VrackDedicatedConnect = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "VrackDedicatedConnect",
+}) as any as S.Schema<VrackDedicatedConnect>;
+
+export interface GetVrackDedicatedServerRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Dedicated Server */
+  dedicatedServer: string;
+}
+export const GetVrackDedicatedServerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    dedicatedServer: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/dedicatedServer/{dedicatedServer}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetVrackDedicatedServerRequest",
+}) as any as S.Schema<GetVrackDedicatedServerRequest>;
+
+/** vrack dedicated server interfaces (LEGACY) */
+export interface VrackDedicatedServer {
+  /** Dedicated Server */
+  dedicatedServer?: string;
+  /** vrack name */
+  vrack?: string;
+}
+export const VrackDedicatedServer = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    dedicatedServer: S.optional(S.String),
+    vrack: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "VrackDedicatedServer",
+}) as any as S.Schema<VrackDedicatedServer>;
+
+export interface GetVrackDedicatedServerInterfaceRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Dedicated Server Interface */
+  dedicatedServerInterface: string;
+}
+export const GetVrackDedicatedServerInterfaceRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      dedicatedServerInterface: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/vrack/{serviceName}/dedicatedServerInterface/{dedicatedServerInterface}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetVrackDedicatedServerInterfaceRequest",
+}) as any as S.Schema<GetVrackDedicatedServerInterfaceRequest>;
+
+/** vrack dedicated server interfaces */
+export interface VrackDedicatedServerInterface {
+  /** Dedicated Server Interface */
+  dedicatedServerInterface?: string;
+  /** vrack name */
+  vrack?: string;
+}
+export const VrackDedicatedServerInterface = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    dedicatedServerInterface: S.optional(S.String),
+    vrack: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "VrackDedicatedServerInterface",
+}) as any as S.Schema<VrackDedicatedServerInterface>;
+
+export interface GetVrackIpRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Your IP block */
+  ip: string;
+}
+export const GetVrackIpRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    ip: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/vrack/{serviceName}/ip/{ip}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetVrackIpRequest",
+}) as any as S.Schema<GetVrackIpRequest>;
+
+/** Possible values for vrack zone */
+export type VrackVrackZoneEnum =
+  | "bhs"
+  | "cch"
+  | "fra1"
+  | "gra"
+  | "lon1"
+  | "pdx1"
+  | "rbx"
+  | "sbg"
+  | "sgp1"
+  | "syd1"
+  | "syd2"
+  | "was1"
+  | "waw"
+  | "yyz";
+export const VrackVrackZoneEnum = /*@__PURE__*/ S.String;
+
+/** IP block in vrack */
+export interface VrackIp {
+  /** Your gateway */
+  gateway?: string | null;
+  /** Your IP block */
+  ip?: string;
+  /** Where you want your block announced on the network */
+  region?: string | null;
+  /** Where you want your block announced on the network */
+  zone?: VrackVrackZoneEnum | null;
+}
+export const VrackIp = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    gateway: S.optional(S.NullOr(S.String)),
+    ip: S.optional(S.String),
+    region: S.optional(S.NullOr(S.String)),
+    zone: S.optional(S.NullOr(VrackVrackZoneEnum)),
+  }),
+).annotate({ identifier: "VrackIp" }) as any as S.Schema<VrackIp>;
+
+export interface GetVrackIpLoadbalancingRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Your ipLoadbalancing */
+  ipLoadbalancing: string;
+}
+export const GetVrackIpLoadbalancingRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    ipLoadbalancing: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/ipLoadbalancing/{ipLoadbalancing}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetVrackIpLoadbalancingRequest",
+}) as any as S.Schema<GetVrackIpLoadbalancingRequest>;
+
+/** ipLoadbalancing in vrack */
+export interface VrackIplb {
+  /** Your ipLoadbalancing */
+  ipLoadbalancing?: string;
+  /** vrack name */
+  vrack?: string;
+}
+export const VrackIplb = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ipLoadbalancing: S.optional(S.String),
+    vrack: S.optional(S.String),
+  }),
+).annotate({ identifier: "VrackIplb" }) as any as S.Schema<VrackIplb>;
+
+export interface GetVrackIpv6Request {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Your IP v6 block */
+  ipv6: string;
+}
+export const GetVrackIpv6Request = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    ipv6: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/ipv6/{ipv6}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetVrackIpv6Request",
+}) as any as S.Schema<GetVrackIpv6Request>;
+
+/** IP v6 block in vrack */
+export interface VrackIpv6 {
+  /** Your IP v6 block */
+  ipv6?: string;
+  /** Where you want your block announced on the network */
+  region?: string | null;
+}
+export const VrackIpv6 = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ipv6: S.optional(S.String),
+    region: S.optional(S.NullOr(S.String)),
+  }),
+).annotate({ identifier: "VrackIpv6" }) as any as S.Schema<VrackIpv6>;
+
+export interface GetVrackIpv6BridgedSubrangeRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Your IP v6 block */
+  ipv6: string;
+  /** subrange bridged into your vrack */
+  bridgedSubrange: string;
+}
+export const GetVrackIpv6BridgedSubrangeRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    ipv6: S.String.pipe(T.Label()),
+    bridgedSubrange: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/ipv6/{ipv6}/bridgedSubrange/{bridgedSubrange}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetVrackIpv6BridgedSubrangeRequest",
+}) as any as S.Schema<GetVrackIpv6BridgedSubrangeRequest>;
+
+/** Possible values for slaac */
+export type VrackSlaacEnum = "disabled" | "enabled";
+export const VrackSlaacEnum = /*@__PURE__*/ S.String;
+
+/** Bridged subrange within your IP v6 block */
+export interface VrackBridgedSubrange {
+  /** subrange bridged into your vrack */
+  bridgedSubrange?: string;
+  /** Your gateway */
+  gateway?: string;
+  /** Slaac status */
+  slaac?: VrackSlaacEnum;
+}
+export const VrackBridgedSubrange = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    bridgedSubrange: S.optional(S.String),
+    gateway: S.optional(S.String),
+    slaac: S.optional(VrackSlaacEnum),
+  }),
+).annotate({
+  identifier: "VrackBridgedSubrange",
+}) as any as S.Schema<VrackBridgedSubrange>;
+
+export interface GetVrackIpv6RoutedSubrangeRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Your IP v6 block */
+  ipv6: string;
+  /** subrange routed into your vrack */
+  routedSubrange: string;
+}
+export const GetVrackIpv6RoutedSubrangeRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    ipv6: S.String.pipe(T.Label()),
+    routedSubrange: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/ipv6/{ipv6}/routedSubrange/{routedSubrange}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetVrackIpv6RoutedSubrangeRequest",
+}) as any as S.Schema<GetVrackIpv6RoutedSubrangeRequest>;
+
+/** Routed subranges within your IP v6 block */
+export interface VrackRoutedSubrange {
+  /** nexthop used as a gateway for your routed subrange */
+  nexthop?: string;
+  /** subrange routed into your vrack */
+  routedSubrange?: string;
+}
+export const VrackRoutedSubrange = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    nexthop: S.optional(S.String),
+    routedSubrange: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "VrackRoutedSubrange",
+}) as any as S.Schema<VrackRoutedSubrange>;
+
+export interface GetVrackLegacyVrackRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** your legacy vrack service */
+  legacyVrack: string;
+}
+export const GetVrackLegacyVrackRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    legacyVrack: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/legacyVrack/{legacyVrack}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetVrackLegacyVrackRequest",
+}) as any as S.Schema<GetVrackLegacyVrackRequest>;
+
+/** interface between legacy vrack (vrackXXXX) and vrack (pn-XXXX) */
+export interface VrackLegacyVrack {
+  /** your legacy vrack service */
+  legacyVrack?: string;
+  /** vlan to set on legacy vrack equipments */
+  vlanId?: number;
+}
+export const VrackLegacyVrack = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    legacyVrack: S.optional(S.String),
+    vlanId: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "VrackLegacyVrack",
+}) as any as S.Schema<VrackLegacyVrack>;
+
+export interface GetVrackOvhCloudConnectRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** ovhCloudConnect service name */
+  ovhCloudConnect: string;
+}
+export const GetVrackOvhCloudConnectRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    ovhCloudConnect: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/ovhCloudConnect/{ovhCloudConnect}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetVrackOvhCloudConnectRequest",
+}) as any as S.Schema<GetVrackOvhCloudConnectRequest>;
+
+/** ovhCloudConnect in vrack */
+export interface VrackOvhCloudConnect {
+  /** ovhCloudConnect service name */
+  ovhCloudConnect?: string;
+  /** vrack name */
+  vrack?: string;
+}
+export const VrackOvhCloudConnect = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ovhCloudConnect: S.optional(S.String),
+    vrack: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "VrackOvhCloudConnect",
+}) as any as S.Schema<VrackOvhCloudConnect>;
+
+export interface GetVrackPublicRoutingOptionRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+}
+export const GetVrackPublicRoutingOptionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/publicRoutingOption",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetVrackPublicRoutingOptionRequest",
+}) as any as S.Schema<GetVrackPublicRoutingOptionRequest>;
+
+/** A structure describing the public routing option */
+export interface VrackPublicRoutingOption {
+  /** Global bandwidth for blocks in your vrack (in Mbps) */
+  bandwidth?: number | null;
+}
+export const VrackPublicRoutingOption = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    bandwidth: S.optional(S.NullOr(S.Number)),
+  }),
+).annotate({
+  identifier: "VrackPublicRoutingOption",
+}) as any as S.Schema<VrackPublicRoutingOption>;
+
+export interface GetVrackServiceInfosRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+}
+export const GetVrackServiceInfosRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/serviceInfos",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetVrackServiceInfosRequest",
+}) as any as S.Schema<GetVrackServiceInfosRequest>;
+
+export type ServiceStateEnum =
+  | "autorenewInProgress"
+  | "expired"
+  | "inCreation"
+  | "ok"
+  | "pendingDebt"
+  | "unPaid";
+export const ServiceStateEnum = /*@__PURE__*/ S.String;
+
+/** Details about a non-expiring Service */
+export interface ServicesNonExpiringService {
+  contactAdmin?: string;
+  contactBilling?: string;
+  contactTech?: string;
+  creation?: string;
+  domain?: string;
+  serviceId?: number;
+  status?: ServiceStateEnum;
+}
+export const ServicesNonExpiringService = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    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),
+    serviceId: S.optional(S.Number),
+    status: S.optional(ServiceStateEnum),
+  }),
+).annotate({
+  identifier: "ServicesNonExpiringService",
+}) as any as S.Schema<ServicesNonExpiringService>;
+
+export interface GetVrackTaskRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  taskId: number;
+}
+export const GetVrackTaskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    taskId: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/task/{taskId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetVrackTaskRequest",
+}) as any as S.Schema<GetVrackTaskRequest>;
+
+export interface GetVrackVmwareCloudDirectorVirtualDataCenterRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** vmwareCloudDirectorVirtualDataCenter service name */
+  vmwareCloudDirectorVirtualDataCenter: string;
+}
+export const GetVrackVmwareCloudDirectorVirtualDataCenterRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      vmwareCloudDirectorVirtualDataCenter: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/vrack/{serviceName}/vmwareCloudDirectorVirtualDataCenter/{vmwareCloudDirectorVirtualDataCenter}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GetVrackVmwareCloudDirectorVirtualDataCenterRequest",
+  }) as any as S.Schema<GetVrackVmwareCloudDirectorVirtualDataCenterRequest>;
+
+/** vmwareCloudDirector virtualDataCenter in vrack */
+export interface VrackVmwareCloudDirectorVirtualDataCenter {
+  /** vmwareCloudDirectorVirtualDataCenter service name */
+  vmwareCloudDirectorVirtualDataCenter?: string;
+  /** vrack name */
+  vrack?: string;
+}
+export const VrackVmwareCloudDirectorVirtualDataCenter =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      vmwareCloudDirectorVirtualDataCenter: S.optional(S.String),
+      vrack: S.optional(S.String),
+    }),
+  ).annotate({
+    identifier: "VrackVmwareCloudDirectorVirtualDataCenter",
+  }) as any as S.Schema<VrackVmwareCloudDirectorVirtualDataCenter>;
+
+export interface GetVrackVrackServiceRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** vrackServices service name */
+  vrackServices: string;
+}
+export const GetVrackVrackServiceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    vrackServices: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/vrackServices/{vrackServices}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetVrackVrackServiceRequest",
+}) as any as S.Schema<GetVrackVrackServiceRequest>;
+
+/** vrackServices in vrack */
+export interface VrackVrackServices {
+  /** vrack name */
+  vrack?: string;
+  /** vrackServices service name */
+  vrackServices?: string;
+}
+export const VrackVrackServices = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    vrack: S.optional(S.String),
+    vrackServices: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "VrackVrackServices",
+}) as any as S.Schema<VrackVrackServices>;
+
+/** 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 ListVrackRequestIamTagsValueList = Array<IamResourceTagFilterInput>;
+export const ListVrackRequestIamTagsValueList = /*@__PURE__*/ S.Array(
+  IamResourceTagFilterInput,
+) as any as S.Schema<ListVrackRequestIamTagsValueList>;
+
+export type ListVrackRequestIamTagsMap = {
+  [key: string]: ListVrackRequestIamTagsValueList | undefined;
+};
+export const ListVrackRequestIamTagsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  ListVrackRequestIamTagsValueList,
+) as any as S.Schema<ListVrackRequestIamTagsMap>;
+
+export interface ListVrackRequest {
+  /** Filter resources on IAM tags */
+  iamTags?: ListVrackRequestIamTagsMap;
+}
+export const ListVrackRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    iamTags: S.optional(ListVrackRequestIamTagsMap.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/vrack", code: 200 })),
+).annotate({
+  identifier: "ListVrackRequest",
+}) as any as S.Schema<ListVrackRequest>;
+
+export type ListVrackResponseBodyList = Array<string>;
+export const ListVrackResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListVrackResponseBodyList>;
+
+export type ListVrackResponse = ListVrackResponseBodyList;
+export const ListVrackResponse = /*@__PURE__*/ S.suspend(() =>
+  ListVrackResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListVrackResponse",
+}) as any as S.Schema<ListVrackResponse>;
+
+/** Possible values for vrack allowed service */
+export type VrackAllowedServiceEnum =
+  | "cloudProject"
+  | "dedicatedCloud"
+  | "dedicatedCloudDatacenter"
+  | "dedicatedConnect"
+  | "dedicatedServer"
+  | "dedicatedServerInterface"
+  | "ip"
+  | "ipLoadbalancing"
+  | "ipv6"
+  | "legacyVrack"
+  | "ovhCloudConnect"
+  | "vmwareCloudDirectorVirtualDataCenter"
+  | "vrackServices";
+export const VrackAllowedServiceEnum = /*@__PURE__*/ S.String;
+
+export interface ListVrackAllowedServicesRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Filter on a specific service family */
+  serviceFamily?: VrackAllowedServiceEnum | (string & {});
+}
+export const ListVrackAllowedServicesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    serviceFamily: S.optional(VrackAllowedServiceEnum.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/allowedServices",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListVrackAllowedServicesRequest",
+}) as any as S.Schema<ListVrackAllowedServicesRequest>;
+
+/** list of publicCloud projects allowed to be connected to vrack */
+export type VrackAllowedServicesCloudProjectList = Array<string>;
+export const VrackAllowedServicesCloudProjectList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VrackAllowedServicesCloudProjectList>;
+
+/** list of dedicated cloud allowed to be connected to vrack */
+export type VrackAllowedServicesDedicatedCloudList = Array<string>;
+export const VrackAllowedServicesDedicatedCloudList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VrackAllowedServicesDedicatedCloudList>;
+
+/** list of dedicated cloud datacenters allowed to be connected to vrack */
+export type VrackAllowedServicesDedicatedCloudDatacenterList = Array<string>;
+export const VrackAllowedServicesDedicatedCloudDatacenterList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<VrackAllowedServicesDedicatedCloudDatacenterList>;
+
+/** list of dedicated connect links allowed to be connected to vrack */
+export type VrackAllowedServicesDedicatedConnectList = Array<string>;
+export const VrackAllowedServicesDedicatedConnectList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VrackAllowedServicesDedicatedConnectList>;
+
+/** list of dedicated servers allowed to be connected to vrack */
+export type VrackAllowedServicesDedicatedServerList = Array<string>;
+export const VrackAllowedServicesDedicatedServerList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VrackAllowedServicesDedicatedServerList>;
+
+/** A structure giving all dedicated server interfaces allowed for this vrack */
+export interface VrackAllowedDedicatedServerInterfaces {
+  /** the name of dedicatedServer */
+  dedicatedServer?: string;
+  /** the unique identifier of dedicatedServerInterface */
+  dedicatedServerInterface?: string;
+  /** the name of dedicatedServerInterface */
+  name?: string;
+}
+export const VrackAllowedDedicatedServerInterfaces = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      dedicatedServer: S.optional(S.String),
+      dedicatedServerInterface: S.optional(S.String),
+      name: S.optional(S.String),
+    }),
+).annotate({
+  identifier: "VrackAllowedDedicatedServerInterfaces",
+}) as any as S.Schema<VrackAllowedDedicatedServerInterfaces>;
+
+/** list of dedicated server interfaces allowed to be connected to vrack */
+export type VrackAllowedServicesDedicatedServerInterfaceList =
+  Array<VrackAllowedDedicatedServerInterfaces>;
+export const VrackAllowedServicesDedicatedServerInterfaceList =
+  /*@__PURE__*/ S.Array(
+    VrackAllowedDedicatedServerInterfaces,
+  ) as any as S.Schema<VrackAllowedServicesDedicatedServerInterfaceList>;
+
+/** list of blocks allowed to be connected to vrack */
+export type VrackAllowedServicesIpList = Array<string>;
+export const VrackAllowedServicesIpList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VrackAllowedServicesIpList>;
+
+/** list of ipLoadbalancing allowed to be connected to vrack */
+export type VrackAllowedServicesIpLoadbalancingList = Array<string>;
+export const VrackAllowedServicesIpLoadbalancingList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VrackAllowedServicesIpLoadbalancingList>;
+
+/** list of ipv6 blocks allowed to be connected to vrack */
+export type VrackAllowedServicesIpv6List = Array<string>;
+export const VrackAllowedServicesIpv6List = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VrackAllowedServicesIpv6List>;
+
+/** list of legacy vrack (1.0) allowed to be connected to vrack */
+export type VrackAllowedServicesLegacyVrackList = Array<string>;
+export const VrackAllowedServicesLegacyVrackList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VrackAllowedServicesLegacyVrackList>;
+
+/** List of the ovhCloudConnect services allowed to be connected to vrack */
+export type VrackAllowedServicesOvhCloudConnectList = Array<string>;
+export const VrackAllowedServicesOvhCloudConnectList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VrackAllowedServicesOvhCloudConnectList>;
+
+/** List of the vmwareCloudDirectorVirtualDataCenter allowed to be connected to vrack */
+export type VrackAllowedServicesVmwareCloudDirectorVirtualDataCenterList =
+  Array<string>;
+export const VrackAllowedServicesVmwareCloudDirectorVirtualDataCenterList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<VrackAllowedServicesVmwareCloudDirectorVirtualDataCenterList>;
+
+/** List of the vrackServices allowed to be connected to vrack */
+export type VrackAllowedServicesVrackServicesList = Array<string>;
+export const VrackAllowedServicesVrackServicesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VrackAllowedServicesVrackServicesList>;
+
+/** A structure given all service allowed for this vrack */
+export interface VrackAllowedServices {
+  /** list of publicCloud projects allowed to be connected to vrack */
+  cloudProject?: VrackAllowedServicesCloudProjectList | null;
+  /** list of dedicated cloud allowed to be connected to vrack */
+  dedicatedCloud?: VrackAllowedServicesDedicatedCloudList | null;
+  /** list of dedicated cloud datacenters allowed to be connected to vrack */
+  dedicatedCloudDatacenter?: VrackAllowedServicesDedicatedCloudDatacenterList | null;
+  /** list of dedicated connect links allowed to be connected to vrack */
+  dedicatedConnect?: VrackAllowedServicesDedicatedConnectList | null;
+  /** list of dedicated servers allowed to be connected to vrack */
+  dedicatedServer?: VrackAllowedServicesDedicatedServerList | null;
+  /** list of dedicated server interfaces allowed to be connected to vrack */
+  dedicatedServerInterface?: VrackAllowedServicesDedicatedServerInterfaceList | null;
+  /** list of blocks allowed to be connected to vrack */
+  ip?: VrackAllowedServicesIpList | null;
+  /** list of ipLoadbalancing allowed to be connected to vrack */
+  ipLoadbalancing?: VrackAllowedServicesIpLoadbalancingList | null;
+  /** list of ipv6 blocks allowed to be connected to vrack */
+  ipv6?: VrackAllowedServicesIpv6List | null;
+  /** list of legacy vrack (1.0) allowed to be connected to vrack */
+  legacyVrack?: VrackAllowedServicesLegacyVrackList | null;
+  /** List of the ovhCloudConnect services allowed to be connected to vrack */
+  ovhCloudConnect?: VrackAllowedServicesOvhCloudConnectList | null;
+  /** List of the vmwareCloudDirectorVirtualDataCenter allowed to be connected to vrack */
+  vmwareCloudDirectorVirtualDataCenter?: VrackAllowedServicesVmwareCloudDirectorVirtualDataCenterList | null;
+  /** List of the vrackServices allowed to be connected to vrack */
+  vrackServices?: VrackAllowedServicesVrackServicesList | null;
+}
+export const VrackAllowedServices = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cloudProject: S.optional(S.NullOr(VrackAllowedServicesCloudProjectList)),
+    dedicatedCloud: S.optional(
+      S.NullOr(VrackAllowedServicesDedicatedCloudList),
+    ),
+    dedicatedCloudDatacenter: S.optional(
+      S.NullOr(VrackAllowedServicesDedicatedCloudDatacenterList),
+    ),
+    dedicatedConnect: S.optional(
+      S.NullOr(VrackAllowedServicesDedicatedConnectList),
+    ),
+    dedicatedServer: S.optional(
+      S.NullOr(VrackAllowedServicesDedicatedServerList),
+    ),
+    dedicatedServerInterface: S.optional(
+      S.NullOr(VrackAllowedServicesDedicatedServerInterfaceList),
+    ),
+    ip: S.optional(S.NullOr(VrackAllowedServicesIpList)),
+    ipLoadbalancing: S.optional(
+      S.NullOr(VrackAllowedServicesIpLoadbalancingList),
+    ),
+    ipv6: S.optional(S.NullOr(VrackAllowedServicesIpv6List)),
+    legacyVrack: S.optional(S.NullOr(VrackAllowedServicesLegacyVrackList)),
+    ovhCloudConnect: S.optional(
+      S.NullOr(VrackAllowedServicesOvhCloudConnectList),
+    ),
+    vmwareCloudDirectorVirtualDataCenter: S.optional(
+      S.NullOr(VrackAllowedServicesVmwareCloudDirectorVirtualDataCenterList),
+    ),
+    vrackServices: S.optional(S.NullOr(VrackAllowedServicesVrackServicesList)),
+  }),
+).annotate({
+  identifier: "VrackAllowedServices",
+}) as any as S.Schema<VrackAllowedServices>;
+
+export interface ListVrackCloudProjectRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+}
+export const ListVrackCloudProjectRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/cloudProject",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListVrackCloudProjectRequest",
+}) as any as S.Schema<ListVrackCloudProjectRequest>;
+
+export type ListVrackCloudProjectResponseBodyList = Array<string>;
+export const ListVrackCloudProjectResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListVrackCloudProjectResponseBodyList>;
+
+export type ListVrackCloudProjectResponse =
+  ListVrackCloudProjectResponseBodyList;
+export const ListVrackCloudProjectResponse = /*@__PURE__*/ S.suspend(() =>
+  ListVrackCloudProjectResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListVrackCloudProjectResponse",
+}) as any as S.Schema<ListVrackCloudProjectResponse>;
+
+export interface ListVrackDedicatedCloudRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+}
+export const ListVrackDedicatedCloudRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/dedicatedCloud",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListVrackDedicatedCloudRequest",
+}) as any as S.Schema<ListVrackDedicatedCloudRequest>;
+
+export type ListVrackDedicatedCloudResponseBodyList = Array<string>;
+export const ListVrackDedicatedCloudResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListVrackDedicatedCloudResponseBodyList>;
+
+export type ListVrackDedicatedCloudResponse =
+  ListVrackDedicatedCloudResponseBodyList;
+export const ListVrackDedicatedCloudResponse = /*@__PURE__*/ S.suspend(() =>
+  ListVrackDedicatedCloudResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListVrackDedicatedCloudResponse",
+}) as any as S.Schema<ListVrackDedicatedCloudResponse>;
+
+export interface ListVrackDedicatedCloudDatacenterRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+}
+export const ListVrackDedicatedCloudDatacenterRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/vrack/{serviceName}/dedicatedCloudDatacenter",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListVrackDedicatedCloudDatacenterRequest",
+}) as any as S.Schema<ListVrackDedicatedCloudDatacenterRequest>;
+
+export type ListVrackDedicatedCloudDatacenterResponseBodyList = Array<string>;
+export const ListVrackDedicatedCloudDatacenterResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListVrackDedicatedCloudDatacenterResponseBodyList>;
+
+export type ListVrackDedicatedCloudDatacenterResponse =
+  ListVrackDedicatedCloudDatacenterResponseBodyList;
+export const ListVrackDedicatedCloudDatacenterResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListVrackDedicatedCloudDatacenterResponseBodyList.pipe(T.RawResponseRoot()),
+  ).annotate({
+    identifier: "ListVrackDedicatedCloudDatacenterResponse",
+  }) as any as S.Schema<ListVrackDedicatedCloudDatacenterResponse>;
+
+export interface ListVrackDedicatedCloudDatacenterAllowedVrackRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Your dedicatedCloud datacenter name */
+  datacenter: string;
+}
+export const ListVrackDedicatedCloudDatacenterAllowedVrackRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      datacenter: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/vrack/{serviceName}/dedicatedCloudDatacenter/{datacenter}/allowedVrack",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListVrackDedicatedCloudDatacenterAllowedVrackRequest",
+  }) as any as S.Schema<ListVrackDedicatedCloudDatacenterAllowedVrackRequest>;
+
+export type ListVrackDedicatedCloudDatacenterAllowedVrackResponseBodyList =
+  Array<string>;
+export const ListVrackDedicatedCloudDatacenterAllowedVrackResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListVrackDedicatedCloudDatacenterAllowedVrackResponseBodyList>;
+
+export type ListVrackDedicatedCloudDatacenterAllowedVrackResponse =
+  ListVrackDedicatedCloudDatacenterAllowedVrackResponseBodyList;
+export const ListVrackDedicatedCloudDatacenterAllowedVrackResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListVrackDedicatedCloudDatacenterAllowedVrackResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListVrackDedicatedCloudDatacenterAllowedVrackResponse",
+  }) as any as S.Schema<ListVrackDedicatedCloudDatacenterAllowedVrackResponse>;
+
+export interface ListVrackDedicatedConnectRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+}
+export const ListVrackDedicatedConnectRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/dedicatedConnect",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListVrackDedicatedConnectRequest",
+}) as any as S.Schema<ListVrackDedicatedConnectRequest>;
+
+export type ListVrackDedicatedConnectResponseBodyList = Array<string>;
+export const ListVrackDedicatedConnectResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListVrackDedicatedConnectResponseBodyList>;
+
+export type ListVrackDedicatedConnectResponse =
+  ListVrackDedicatedConnectResponseBodyList;
+export const ListVrackDedicatedConnectResponse = /*@__PURE__*/ S.suspend(() =>
+  ListVrackDedicatedConnectResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListVrackDedicatedConnectResponse",
+}) as any as S.Schema<ListVrackDedicatedConnectResponse>;
+
+export interface ListVrackDedicatedServerRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+}
+export const ListVrackDedicatedServerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/dedicatedServer",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListVrackDedicatedServerRequest",
+}) as any as S.Schema<ListVrackDedicatedServerRequest>;
+
+export type ListVrackDedicatedServerResponseBodyList = Array<string>;
+export const ListVrackDedicatedServerResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListVrackDedicatedServerResponseBodyList>;
+
+export type ListVrackDedicatedServerResponse =
+  ListVrackDedicatedServerResponseBodyList;
+export const ListVrackDedicatedServerResponse = /*@__PURE__*/ S.suspend(() =>
+  ListVrackDedicatedServerResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListVrackDedicatedServerResponse",
+}) as any as S.Schema<ListVrackDedicatedServerResponse>;
+
+export interface ListVrackDedicatedServerInterfaceRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+}
+export const ListVrackDedicatedServerInterfaceRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/vrack/{serviceName}/dedicatedServerInterface",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListVrackDedicatedServerInterfaceRequest",
+}) as any as S.Schema<ListVrackDedicatedServerInterfaceRequest>;
+
+export type ListVrackDedicatedServerInterfaceResponseBodyList = Array<string>;
+export const ListVrackDedicatedServerInterfaceResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListVrackDedicatedServerInterfaceResponseBodyList>;
+
+export type ListVrackDedicatedServerInterfaceResponse =
+  ListVrackDedicatedServerInterfaceResponseBodyList;
+export const ListVrackDedicatedServerInterfaceResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListVrackDedicatedServerInterfaceResponseBodyList.pipe(T.RawResponseRoot()),
+  ).annotate({
+    identifier: "ListVrackDedicatedServerInterfaceResponse",
+  }) as any as S.Schema<ListVrackDedicatedServerInterfaceResponse>;
+
+export interface ListVrackDedicatedServerInterfaceDetailsRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+}
+export const ListVrackDedicatedServerInterfaceDetailsRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/vrack/{serviceName}/dedicatedServerInterfaceDetails",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListVrackDedicatedServerInterfaceDetailsRequest",
+  }) as any as S.Schema<ListVrackDedicatedServerInterfaceDetailsRequest>;
+
+export type ListVrackDedicatedServerInterfaceDetailsResponseBodyList =
+  Array<VrackAllowedDedicatedServerInterfaces>;
+export const ListVrackDedicatedServerInterfaceDetailsResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    VrackAllowedDedicatedServerInterfaces,
+  ) as any as S.Schema<ListVrackDedicatedServerInterfaceDetailsResponseBodyList>;
+
+export type ListVrackDedicatedServerInterfaceDetailsResponse =
+  ListVrackDedicatedServerInterfaceDetailsResponseBodyList;
+export const ListVrackDedicatedServerInterfaceDetailsResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListVrackDedicatedServerInterfaceDetailsResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListVrackDedicatedServerInterfaceDetailsResponse",
+  }) as any as S.Schema<ListVrackDedicatedServerInterfaceDetailsResponse>;
+
+export interface ListVrackEligibleServicesRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+}
+export const ListVrackEligibleServicesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/eligibleServices",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListVrackEligibleServicesRequest",
+}) as any as S.Schema<ListVrackEligibleServicesRequest>;
+
+/** List of services where an error has been encountered */
+export type VrackEligibleServicesResponseErrorsList = Array<string>;
+export const VrackEligibleServicesResponseErrorsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VrackEligibleServicesResponseErrorsList>;
+
+/** List of publicCloud projects allowed to be connected to this vRack */
+export type VrackEligibleServicesCloudProjectList = Array<string>;
+export const VrackEligibleServicesCloudProjectList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VrackEligibleServicesCloudProjectList>;
+
+/** List of dedicated cloud allowed to be connected to this vRack */
+export type VrackEligibleServicesDedicatedCloudList = Array<string>;
+export const VrackEligibleServicesDedicatedCloudList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VrackEligibleServicesDedicatedCloudList>;
+
+/** List of dedicated cloud datacenters allowed to be connected to this vRack */
+export type VrackEligibleServicesDedicatedCloudDatacenterList = Array<string>;
+export const VrackEligibleServicesDedicatedCloudDatacenterList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<VrackEligibleServicesDedicatedCloudDatacenterList>;
+
+/** List of dedicated connect links allowed to be connected to this vRack */
+export type VrackEligibleServicesDedicatedConnectList = Array<string>;
+export const VrackEligibleServicesDedicatedConnectList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VrackEligibleServicesDedicatedConnectList>;
+
+/** List of dedicated servers allowed to be connected to this vRack */
+export type VrackEligibleServicesDedicatedServerList = Array<string>;
+export const VrackEligibleServicesDedicatedServerList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VrackEligibleServicesDedicatedServerList>;
+
+/** Dedicated server interfaces allowed for this vRack */
+export interface VrackEligibleDedicatedServerInterfaces {
+  /** The name of the dedicatedServer */
+  dedicatedServer?: string;
+  /** The unique identifier of the dedicatedServerInterface */
+  dedicatedServerInterface?: string;
+  /** The name of the dedicatedServerInterface */
+  name?: string;
+}
+export const VrackEligibleDedicatedServerInterfaces = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      dedicatedServer: S.optional(S.String),
+      dedicatedServerInterface: S.optional(S.String),
+      name: S.optional(S.String),
+    }),
+).annotate({
+  identifier: "VrackEligibleDedicatedServerInterfaces",
+}) as any as S.Schema<VrackEligibleDedicatedServerInterfaces>;
+
+/** List of dedicated server interfaces allowed to be connected to this vRack */
+export type VrackEligibleServicesDedicatedServerInterfaceList =
+  Array<VrackEligibleDedicatedServerInterfaces>;
+export const VrackEligibleServicesDedicatedServerInterfaceList =
+  /*@__PURE__*/ S.Array(
+    VrackEligibleDedicatedServerInterfaces,
+  ) as any as S.Schema<VrackEligibleServicesDedicatedServerInterfaceList>;
+
+/** List of blocks allowed to be connected to this vRack */
+export type VrackEligibleServicesIpList = Array<string>;
+export const VrackEligibleServicesIpList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VrackEligibleServicesIpList>;
+
+/** List of ipLoadbalancing allowed to be connected to this vRack */
+export type VrackEligibleServicesIpLoadbalancingList = Array<string>;
+export const VrackEligibleServicesIpLoadbalancingList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VrackEligibleServicesIpLoadbalancingList>;
+
+/** List of ipv6 blocks allowed to be connected to this vRack */
+export type VrackEligibleServicesIpv6List = Array<string>;
+export const VrackEligibleServicesIpv6List = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VrackEligibleServicesIpv6List>;
+
+/** List of legacy vRack (1.0) allowed to be connected to this vRack */
+export type VrackEligibleServicesLegacyVrackList = Array<string>;
+export const VrackEligibleServicesLegacyVrackList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VrackEligibleServicesLegacyVrackList>;
+
+/** List of the ovhCloudConnect services allowed to be connected to this vRack */
+export type VrackEligibleServicesOvhCloudConnectList = Array<string>;
+export const VrackEligibleServicesOvhCloudConnectList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VrackEligibleServicesOvhCloudConnectList>;
+
+/** List of the VMwareCloudDirectorVirtualDatacenter allowed to be connected to this vRack */
+export type VrackEligibleServicesVmwareCloudDirectorVirtualDataCenterList =
+  Array<string>;
+export const VrackEligibleServicesVmwareCloudDirectorVirtualDataCenterList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<VrackEligibleServicesVmwareCloudDirectorVirtualDataCenterList>;
+
+/** List of the vrackServices allowed to be connected to this vRack */
+export type VrackEligibleServicesVrackServicesList = Array<string>;
+export const VrackEligibleServicesVrackServicesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VrackEligibleServicesVrackServicesList>;
+
+/** Eligible services for this vRack */
+export interface VrackEligibleServices {
+  /** List of publicCloud projects allowed to be connected to this vRack */
+  cloudProject?: VrackEligibleServicesCloudProjectList | null;
+  /** List of dedicated cloud allowed to be connected to this vRack */
+  dedicatedCloud?: VrackEligibleServicesDedicatedCloudList | null;
+  /** List of dedicated cloud datacenters allowed to be connected to this vRack */
+  dedicatedCloudDatacenter?: VrackEligibleServicesDedicatedCloudDatacenterList | null;
+  /** List of dedicated connect links allowed to be connected to this vRack */
+  dedicatedConnect?: VrackEligibleServicesDedicatedConnectList | null;
+  /** List of dedicated servers allowed to be connected to this vRack */
+  dedicatedServer?: VrackEligibleServicesDedicatedServerList | null;
+  /** List of dedicated server interfaces allowed to be connected to this vRack */
+  dedicatedServerInterface?: VrackEligibleServicesDedicatedServerInterfaceList | null;
+  /** List of blocks allowed to be connected to this vRack */
+  ip?: VrackEligibleServicesIpList | null;
+  /** List of ipLoadbalancing allowed to be connected to this vRack */
+  ipLoadbalancing?: VrackEligibleServicesIpLoadbalancingList | null;
+  /** List of ipv6 blocks allowed to be connected to this vRack */
+  ipv6?: VrackEligibleServicesIpv6List | null;
+  /** List of legacy vRack (1.0) allowed to be connected to this vRack */
+  legacyVrack?: VrackEligibleServicesLegacyVrackList | null;
+  /** List of the ovhCloudConnect services allowed to be connected to this vRack */
+  ovhCloudConnect?: VrackEligibleServicesOvhCloudConnectList | null;
+  /** List of the VMwareCloudDirectorVirtualDatacenter allowed to be connected to this vRack */
+  vmwareCloudDirectorVirtualDataCenter?: VrackEligibleServicesVmwareCloudDirectorVirtualDataCenterList | null;
+  /** List of the vrackServices allowed to be connected to this vRack */
+  vrackServices?: VrackEligibleServicesVrackServicesList | null;
+}
+export const VrackEligibleServices = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cloudProject: S.optional(S.NullOr(VrackEligibleServicesCloudProjectList)),
+    dedicatedCloud: S.optional(
+      S.NullOr(VrackEligibleServicesDedicatedCloudList),
+    ),
+    dedicatedCloudDatacenter: S.optional(
+      S.NullOr(VrackEligibleServicesDedicatedCloudDatacenterList),
+    ),
+    dedicatedConnect: S.optional(
+      S.NullOr(VrackEligibleServicesDedicatedConnectList),
+    ),
+    dedicatedServer: S.optional(
+      S.NullOr(VrackEligibleServicesDedicatedServerList),
+    ),
+    dedicatedServerInterface: S.optional(
+      S.NullOr(VrackEligibleServicesDedicatedServerInterfaceList),
+    ),
+    ip: S.optional(S.NullOr(VrackEligibleServicesIpList)),
+    ipLoadbalancing: S.optional(
+      S.NullOr(VrackEligibleServicesIpLoadbalancingList),
+    ),
+    ipv6: S.optional(S.NullOr(VrackEligibleServicesIpv6List)),
+    legacyVrack: S.optional(S.NullOr(VrackEligibleServicesLegacyVrackList)),
+    ovhCloudConnect: S.optional(
+      S.NullOr(VrackEligibleServicesOvhCloudConnectList),
+    ),
+    vmwareCloudDirectorVirtualDataCenter: S.optional(
+      S.NullOr(VrackEligibleServicesVmwareCloudDirectorVirtualDataCenterList),
+    ),
+    vrackServices: S.optional(S.NullOr(VrackEligibleServicesVrackServicesList)),
+  }),
+).annotate({
+  identifier: "VrackEligibleServices",
+}) as any as S.Schema<VrackEligibleServices>;
+
+/** Eligible services call response */
+export interface VrackEligibleServicesResponse {
+  /** Creation date of the call */
+  createdAt?: string;
+  /** List of services where an error has been encountered */
+  errors?: VrackEligibleServicesResponseErrorsList;
+  /** Eligible services for this vRack */
+  result?: VrackEligibleServices;
+  /** Status of the call */
+  status?: string;
+}
+export const VrackEligibleServicesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    createdAt: S.optional(S.String),
+    errors: S.optional(VrackEligibleServicesResponseErrorsList),
+    result: S.optional(VrackEligibleServices),
+    status: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "VrackEligibleServicesResponse",
+}) as any as S.Schema<VrackEligibleServicesResponse>;
+
+export interface ListVrackIpRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+}
+export const ListVrackIpRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/vrack/{serviceName}/ip", code: 200 })),
+).annotate({
+  identifier: "ListVrackIpRequest",
+}) as any as S.Schema<ListVrackIpRequest>;
+
+export type ListVrackIpResponseBodyList = Array<string>;
+export const ListVrackIpResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListVrackIpResponseBodyList>;
+
+export type ListVrackIpResponse = ListVrackIpResponseBodyList;
+export const ListVrackIpResponse = /*@__PURE__*/ S.suspend(() =>
+  ListVrackIpResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListVrackIpResponse",
+}) as any as S.Schema<ListVrackIpResponse>;
+
+export interface ListVrackIpLoadbalancingRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+}
+export const ListVrackIpLoadbalancingRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/ipLoadbalancing",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListVrackIpLoadbalancingRequest",
+}) as any as S.Schema<ListVrackIpLoadbalancingRequest>;
+
+export type ListVrackIpLoadbalancingResponseBodyList = Array<string>;
+export const ListVrackIpLoadbalancingResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListVrackIpLoadbalancingResponseBodyList>;
+
+export type ListVrackIpLoadbalancingResponse =
+  ListVrackIpLoadbalancingResponseBodyList;
+export const ListVrackIpLoadbalancingResponse = /*@__PURE__*/ S.suspend(() =>
+  ListVrackIpLoadbalancingResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListVrackIpLoadbalancingResponse",
+}) as any as S.Schema<ListVrackIpLoadbalancingResponse>;
+
+export interface ListVrackIpv6Request {
+  /** The internal name of your vrack */
+  serviceName: string;
+}
+export const ListVrackIpv6Request = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/vrack/{serviceName}/ipv6", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListVrackIpv6Request",
+}) as any as S.Schema<ListVrackIpv6Request>;
+
+export type ListVrackIpv6ResponseBodyList = Array<string>;
+export const ListVrackIpv6ResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListVrackIpv6ResponseBodyList>;
+
+export type ListVrackIpv6Response = ListVrackIpv6ResponseBodyList;
+export const ListVrackIpv6Response = /*@__PURE__*/ S.suspend(() =>
+  ListVrackIpv6ResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListVrackIpv6Response",
+}) as any as S.Schema<ListVrackIpv6Response>;
+
+export interface ListVrackIpv6BridgedSubrangeRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Your IP v6 block */
+  ipv6: string;
+}
+export const ListVrackIpv6BridgedSubrangeRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    ipv6: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/ipv6/{ipv6}/bridgedSubrange",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListVrackIpv6BridgedSubrangeRequest",
+}) as any as S.Schema<ListVrackIpv6BridgedSubrangeRequest>;
+
+export type ListVrackIpv6BridgedSubrangeResponseBodyList = Array<string>;
+export const ListVrackIpv6BridgedSubrangeResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListVrackIpv6BridgedSubrangeResponseBodyList>;
+
+export type ListVrackIpv6BridgedSubrangeResponse =
+  ListVrackIpv6BridgedSubrangeResponseBodyList;
+export const ListVrackIpv6BridgedSubrangeResponse = /*@__PURE__*/ S.suspend(
+  () => ListVrackIpv6BridgedSubrangeResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListVrackIpv6BridgedSubrangeResponse",
+}) as any as S.Schema<ListVrackIpv6BridgedSubrangeResponse>;
+
+export interface ListVrackIpv6RoutedSubrangeRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Your IP v6 block */
+  ipv6: string;
+}
+export const ListVrackIpv6RoutedSubrangeRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    ipv6: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/ipv6/{ipv6}/routedSubrange",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListVrackIpv6RoutedSubrangeRequest",
+}) as any as S.Schema<ListVrackIpv6RoutedSubrangeRequest>;
+
+export type ListVrackIpv6RoutedSubrangeResponseBodyList = Array<string>;
+export const ListVrackIpv6RoutedSubrangeResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListVrackIpv6RoutedSubrangeResponseBodyList>;
+
+export type ListVrackIpv6RoutedSubrangeResponse =
+  ListVrackIpv6RoutedSubrangeResponseBodyList;
+export const ListVrackIpv6RoutedSubrangeResponse = /*@__PURE__*/ S.suspend(() =>
+  ListVrackIpv6RoutedSubrangeResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListVrackIpv6RoutedSubrangeResponse",
+}) as any as S.Schema<ListVrackIpv6RoutedSubrangeResponse>;
+
+export interface ListVrackLegacyVrackRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+}
+export const ListVrackLegacyVrackRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/legacyVrack",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListVrackLegacyVrackRequest",
+}) as any as S.Schema<ListVrackLegacyVrackRequest>;
+
+export type ListVrackLegacyVrackResponseBodyList = Array<string>;
+export const ListVrackLegacyVrackResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListVrackLegacyVrackResponseBodyList>;
+
+export type ListVrackLegacyVrackResponse = ListVrackLegacyVrackResponseBodyList;
+export const ListVrackLegacyVrackResponse = /*@__PURE__*/ S.suspend(() =>
+  ListVrackLegacyVrackResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListVrackLegacyVrackResponse",
+}) as any as S.Schema<ListVrackLegacyVrackResponse>;
+
+export interface ListVrackOvhCloudConnectRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+}
+export const ListVrackOvhCloudConnectRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/ovhCloudConnect",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListVrackOvhCloudConnectRequest",
+}) as any as S.Schema<ListVrackOvhCloudConnectRequest>;
+
+export type ListVrackOvhCloudConnectResponseBodyList = Array<string>;
+export const ListVrackOvhCloudConnectResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListVrackOvhCloudConnectResponseBodyList>;
+
+export type ListVrackOvhCloudConnectResponse =
+  ListVrackOvhCloudConnectResponseBodyList;
+export const ListVrackOvhCloudConnectResponse = /*@__PURE__*/ S.suspend(() =>
+  ListVrackOvhCloudConnectResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListVrackOvhCloudConnectResponse",
+}) as any as S.Schema<ListVrackOvhCloudConnectResponse>;
+
+export interface ListVrackTaskRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+}
+export const ListVrackTaskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/vrack/{serviceName}/task", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListVrackTaskRequest",
+}) as any as S.Schema<ListVrackTaskRequest>;
+
+export type ListVrackTaskResponseBodyList = Array<number>;
+export const ListVrackTaskResponseBodyList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<ListVrackTaskResponseBodyList>;
+
+export type ListVrackTaskResponse = ListVrackTaskResponseBodyList;
+export const ListVrackTaskResponse = /*@__PURE__*/ S.suspend(() =>
+  ListVrackTaskResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListVrackTaskResponse",
+}) as any as S.Schema<ListVrackTaskResponse>;
+
+export interface ListVrackVmwareCloudDirectorVirtualDataCenterRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+}
+export const ListVrackVmwareCloudDirectorVirtualDataCenterRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/vrack/{serviceName}/vmwareCloudDirectorVirtualDataCenter",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListVrackVmwareCloudDirectorVirtualDataCenterRequest",
+  }) as any as S.Schema<ListVrackVmwareCloudDirectorVirtualDataCenterRequest>;
+
+export type ListVrackVmwareCloudDirectorVirtualDataCenterResponseBodyList =
+  Array<string>;
+export const ListVrackVmwareCloudDirectorVirtualDataCenterResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListVrackVmwareCloudDirectorVirtualDataCenterResponseBodyList>;
+
+export type ListVrackVmwareCloudDirectorVirtualDataCenterResponse =
+  ListVrackVmwareCloudDirectorVirtualDataCenterResponseBodyList;
+export const ListVrackVmwareCloudDirectorVirtualDataCenterResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListVrackVmwareCloudDirectorVirtualDataCenterResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListVrackVmwareCloudDirectorVirtualDataCenterResponse",
+  }) as any as S.Schema<ListVrackVmwareCloudDirectorVirtualDataCenterResponse>;
+
+export interface ListVrackVrackServicesRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+}
+export const ListVrackVrackServicesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrack/{serviceName}/vrackServices",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListVrackVrackServicesRequest",
+}) as any as S.Schema<ListVrackVrackServicesRequest>;
+
+export type ListVrackVrackServicesResponseBodyList = Array<string>;
+export const ListVrackVrackServicesResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListVrackVrackServicesResponseBodyList>;
+
+export type ListVrackVrackServicesResponse =
+  ListVrackVrackServicesResponseBodyList;
+export const ListVrackVrackServicesResponse = /*@__PURE__*/ S.suspend(() =>
+  ListVrackVrackServicesResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListVrackVrackServicesResponse",
+}) as any as S.Schema<ListVrackVrackServicesResponse>;
+
+export interface MoveVrackDedicatedCloudDatacenterRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Your dedicatedCloud datacenter name */
+  datacenter: string;
+  /** The internal name of your target vrack */
+  targetServiceName: string;
+}
+export const MoveVrackDedicatedCloudDatacenterRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      serviceName: S.String.pipe(T.Label()),
+      datacenter: S.String.pipe(T.Label()),
+      targetServiceName: S.String,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/vrack/{serviceName}/dedicatedCloudDatacenter/{datacenter}/move",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "MoveVrackDedicatedCloudDatacenterRequest",
+}) as any as S.Schema<MoveVrackDedicatedCloudDatacenterRequest>;
+
+export interface PutVrackRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Description of the vRack */
+  description?: string;
+  /** Name of the vRack */
+  name?: string;
+}
+export const PutVrackRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    description: S.optional(S.String),
+    name: S.optional(S.String),
+  }).pipe(T.Http({ method: "PUT", uri: "/vrack/{serviceName}", code: 200 })),
+).annotate({
+  identifier: "PutVrackRequest",
+}) as any as S.Schema<PutVrackRequest>;
+
+export interface PutVrackResponse {}
+export const PutVrackResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutVrackResponse",
+}) as any as S.Schema<PutVrackResponse>;
+
+export interface PutVrackDedicatedConnectRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** A name for your dedicatedConnect link */
+  name: string;
+}
+export const PutVrackDedicatedConnectRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    name: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/vrack/{serviceName}/dedicatedConnect/{name}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutVrackDedicatedConnectRequest",
+}) as any as S.Schema<PutVrackDedicatedConnectRequest>;
+
+export interface PutVrackDedicatedConnectResponse {}
+export const PutVrackDedicatedConnectResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutVrackDedicatedConnectResponse",
+}) as any as S.Schema<PutVrackDedicatedConnectResponse>;
+
+export interface PutVrackIpv6BridgedSubrangeRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+  /** Your IP v6 block */
+  ipv6: string;
+  /** subrange bridged into your vrack */
+  bridgedSubrange: string;
+  /** Slaac status */
+  slaac?: VrackSlaacEnum | (string & {});
+}
+export const PutVrackIpv6BridgedSubrangeRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+    ipv6: S.String.pipe(T.Label()),
+    bridgedSubrange: S.String.pipe(T.Label()),
+    slaac: S.optional(VrackSlaacEnum),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/vrack/{serviceName}/ipv6/{ipv6}/bridgedSubrange/{bridgedSubrange}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutVrackIpv6BridgedSubrangeRequest",
+}) as any as S.Schema<PutVrackIpv6BridgedSubrangeRequest>;
+
+export interface TerminateVrackRequest {
+  /** The internal name of your vrack */
+  serviceName: string;
+}
+export const TerminateVrackRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/vrack/{serviceName}/terminate",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "TerminateVrackRequest",
+}) as any as S.Schema<TerminateVrackRequest>;
+
+export type TerminateVrackResponse = string;
+export const TerminateVrackResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "TerminateVrackResponse",
+}) as any as S.Schema<TerminateVrackResponse>;
+
+export type ConfirmVrackTerminationError = OvhOpError;
+/** Confirm service termination */
+export const confirmVrackTermination: API.OperationMethod<
+  ConfirmVrackTerminationRequest,
+  ConfirmVrackTerminationResponse,
+  ConfirmVrackTerminationError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ConfirmVrackTerminationRequest,
+  output: ConfirmVrackTerminationResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateVrackChangeContactError = OvhOpError;
+/** Launch a contact change procedure */
+export const createVrackChangeContact: API.OperationMethod<
+  CreateVrackChangeContactRequest,
+  CreateVrackChangeContactResponse,
+  CreateVrackChangeContactError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateVrackChangeContactRequest,
+  output: CreateVrackChangeContactResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateVrackCloudProjectError = OvhOpError;
+/** add a publicCloud project to this vrack */
+export const createVrackCloudProject: API.OperationMethod<
+  CreateVrackCloudProjectRequest,
+  VrackTask,
+  CreateVrackCloudProjectError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateVrackCloudProjectRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateVrackDedicatedCloudError = OvhOpError;
+/** Add VMware on OVHcloud to vRack */
+export const createVrackDedicatedCloud: API.OperationMethod<
+  CreateVrackDedicatedCloudRequest,
+  VrackTask,
+  CreateVrackDedicatedCloudError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateVrackDedicatedCloudRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateVrackDedicatedConnectError = OvhOpError;
+/** add a dedicatedConnect link to this vrack */
+export const createVrackDedicatedConnect: API.OperationMethod<
+  CreateVrackDedicatedConnectRequest,
+  VrackTask,
+  CreateVrackDedicatedConnectError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateVrackDedicatedConnectRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateVrackDedicatedServerError = OvhOpError;
+/** add a dedicated server to this vrack (LEGACY) */
+export const createVrackDedicatedServer: API.OperationMethod<
+  CreateVrackDedicatedServerRequest,
+  VrackTask,
+  CreateVrackDedicatedServerError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateVrackDedicatedServerRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateVrackDedicatedServerInterfaceError = OvhOpError;
+/** add a dedicated server interface to this vrack */
+export const createVrackDedicatedServerInterface: API.OperationMethod<
+  CreateVrackDedicatedServerInterfaceRequest,
+  VrackTask,
+  CreateVrackDedicatedServerInterfaceError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateVrackDedicatedServerInterfaceRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateVrackIpError = OvhOpError;
+/** add an IP block to this vrack */
+export const createVrackIp: API.OperationMethod<
+  CreateVrackIpRequest,
+  VrackTask,
+  CreateVrackIpError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateVrackIpRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateVrackIpLoadbalancingError = OvhOpError;
+/** add an ipLoadbalancing to this vrack */
+export const createVrackIpLoadbalancing: API.OperationMethod<
+  CreateVrackIpLoadbalancingRequest,
+  VrackTask,
+  CreateVrackIpLoadbalancingError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateVrackIpLoadbalancingRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateVrackIpv6Error = OvhOpError;
+/** add an IP v6 block to this vrack */
+export const createVrackIpv6: API.OperationMethod<
+  CreateVrackIpv6Request,
+  VrackTask,
+  CreateVrackIpv6Error,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateVrackIpv6Request,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateVrackIpv6RoutedSubrangeError = OvhOpError;
+/** route a subrange of your IP v6 block into your vrack */
+export const createVrackIpv6RoutedSubrange: API.OperationMethod<
+  CreateVrackIpv6RoutedSubrangeRequest,
+  VrackTask,
+  CreateVrackIpv6RoutedSubrangeError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateVrackIpv6RoutedSubrangeRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateVrackLegacyVrackError = OvhOpError;
+/** add a legacy vrack (vrackXXXX) to this vrack (pn-XXXX) */
+export const createVrackLegacyVrack: API.OperationMethod<
+  CreateVrackLegacyVrackRequest,
+  VrackTask,
+  CreateVrackLegacyVrackError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateVrackLegacyVrackRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateVrackOvhCloudConnectError = OvhOpError;
+/** Add an ovhCloudConnect to the vrack */
+export const createVrackOvhCloudConnect: API.OperationMethod<
+  CreateVrackOvhCloudConnectRequest,
+  VrackTask,
+  CreateVrackOvhCloudConnectError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateVrackOvhCloudConnectRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateVrackVmwareCloudDirectorVirtualDataCenterError = OvhOpError;
+/** Add a vmwareCloudDirectorVirtualDataCenter to the vrack */
+export const createVrackVmwareCloudDirectorVirtualDataCenter: API.OperationMethod<
+  CreateVrackVmwareCloudDirectorVirtualDataCenterRequest,
+  VrackTask,
+  CreateVrackVmwareCloudDirectorVirtualDataCenterError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateVrackVmwareCloudDirectorVirtualDataCenterRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateVrackVrackServiceError = OvhOpError;
+/** Add a vrackServices to the vrack */
+export const createVrackVrackService: API.OperationMethod<
+  CreateVrackVrackServiceRequest,
+  VrackTask,
+  CreateVrackVrackServiceError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateVrackVrackServiceRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteVrackCloudProjectError = OvhOpError;
+/** remove this publicCloud project from this vrack */
+export const deleteVrackCloudProject: API.OperationMethod<
+  DeleteVrackCloudProjectRequest,
+  VrackTask,
+  DeleteVrackCloudProjectError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteVrackCloudProjectRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteVrackDedicatedCloudError = OvhOpError;
+/** Remove VMware on OVHcloud from vRack */
+export const deleteVrackDedicatedCloud: API.OperationMethod<
+  DeleteVrackDedicatedCloudRequest,
+  VrackTask,
+  DeleteVrackDedicatedCloudError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteVrackDedicatedCloudRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteVrackDedicatedConnectError = OvhOpError;
+/** remove this a dedicatedConnect link from this vrack */
+export const deleteVrackDedicatedConnect: API.OperationMethod<
+  DeleteVrackDedicatedConnectRequest,
+  VrackTask,
+  DeleteVrackDedicatedConnectError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteVrackDedicatedConnectRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteVrackDedicatedServerError = OvhOpError;
+/** remove this server from this vrack (LEGACY) */
+export const deleteVrackDedicatedServer: API.OperationMethod<
+  DeleteVrackDedicatedServerRequest,
+  VrackTask,
+  DeleteVrackDedicatedServerError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteVrackDedicatedServerRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteVrackDedicatedServerInterfaceError = OvhOpError;
+/** remove this server interface from this vrack */
+export const deleteVrackDedicatedServerInterface: API.OperationMethod<
+  DeleteVrackDedicatedServerInterfaceRequest,
+  VrackTask,
+  DeleteVrackDedicatedServerInterfaceError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteVrackDedicatedServerInterfaceRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteVrackIpError = OvhOpError;
+/** remove this IP block from this vrack */
+export const deleteVrackIp: API.OperationMethod<
+  DeleteVrackIpRequest,
+  VrackTask,
+  DeleteVrackIpError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteVrackIpRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteVrackIpLoadbalancingError = OvhOpError;
+/** remove this ipLoadbalancing from this vrack */
+export const deleteVrackIpLoadbalancing: API.OperationMethod<
+  DeleteVrackIpLoadbalancingRequest,
+  VrackTask,
+  DeleteVrackIpLoadbalancingError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteVrackIpLoadbalancingRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteVrackIpv6Error = OvhOpError;
+/** remove this IP v6 block from this vrack */
+export const deleteVrackIpv6: API.OperationMethod<
+  DeleteVrackIpv6Request,
+  VrackTask,
+  DeleteVrackIpv6Error,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteVrackIpv6Request,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteVrackIpv6RoutedSubrangeError = OvhOpError;
+/** unroute subrange from your vrack */
+export const deleteVrackIpv6RoutedSubrange: API.OperationMethod<
+  DeleteVrackIpv6RoutedSubrangeRequest,
+  VrackTask,
+  DeleteVrackIpv6RoutedSubrangeError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteVrackIpv6RoutedSubrangeRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteVrackLegacyVrackError = OvhOpError;
+/** remove this legacy vrack (vrackXXXX) from this vrack (pn-XXXX) */
+export const deleteVrackLegacyVrack: API.OperationMethod<
+  DeleteVrackLegacyVrackRequest,
+  VrackTask,
+  DeleteVrackLegacyVrackError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteVrackLegacyVrackRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteVrackOvhCloudConnectError = OvhOpError;
+/** Remove the ovhCloudConnect from the vrack */
+export const deleteVrackOvhCloudConnect: API.OperationMethod<
+  DeleteVrackOvhCloudConnectRequest,
+  VrackTask,
+  DeleteVrackOvhCloudConnectError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteVrackOvhCloudConnectRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteVrackVmwareCloudDirectorVirtualDataCenterError = OvhOpError;
+/** Remove the vmwareCloudDirectorVirtualDataCenter from the vrack */
+export const deleteVrackVmwareCloudDirectorVirtualDataCenter: API.OperationMethod<
+  DeleteVrackVmwareCloudDirectorVirtualDataCenterRequest,
+  VrackTask,
+  DeleteVrackVmwareCloudDirectorVirtualDataCenterError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteVrackVmwareCloudDirectorVirtualDataCenterRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteVrackVrackServiceError = OvhOpError;
+/** Remove the vrackServices from the vrack */
+export const deleteVrackVrackService: API.OperationMethod<
+  DeleteVrackVrackServiceRequest,
+  VrackTask,
+  DeleteVrackVrackServiceError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteVrackVrackServiceRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVrackError = OvhOpError;
+/** Get this object properties */
+export const getVrack: API.OperationMethod<
+  GetVrackRequest,
+  VrackVrackWithIAM,
+  GetVrackError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVrackRequest,
+  output: VrackVrackWithIAM,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVrackCloudProjectError = OvhOpError;
+/** Get this object properties */
+export const getVrackCloudProject: API.OperationMethod<
+  GetVrackCloudProjectRequest,
+  VrackCloudProject,
+  GetVrackCloudProjectError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVrackCloudProjectRequest,
+  output: VrackCloudProject,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVrackDedicatedCloudError = OvhOpError;
+/** Get vRack */
+export const getVrackDedicatedCloud: API.OperationMethod<
+  GetVrackDedicatedCloudRequest,
+  VrackDedicatedCloud,
+  GetVrackDedicatedCloudError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVrackDedicatedCloudRequest,
+  output: VrackDedicatedCloud,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVrackDedicatedCloudDatacenterError = OvhOpError;
+/** Get this object properties */
+export const getVrackDedicatedCloudDatacenter: API.OperationMethod<
+  GetVrackDedicatedCloudDatacenterRequest,
+  VrackPccDatacenter,
+  GetVrackDedicatedCloudDatacenterError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVrackDedicatedCloudDatacenterRequest,
+  output: VrackPccDatacenter,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVrackDedicatedConnectError = OvhOpError;
+/** Get this object properties */
+export const getVrackDedicatedConnect: API.OperationMethod<
+  GetVrackDedicatedConnectRequest,
+  VrackDedicatedConnect,
+  GetVrackDedicatedConnectError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVrackDedicatedConnectRequest,
+  output: VrackDedicatedConnect,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVrackDedicatedServerError = OvhOpError;
+/** Get this object properties */
+export const getVrackDedicatedServer: API.OperationMethod<
+  GetVrackDedicatedServerRequest,
+  VrackDedicatedServer,
+  GetVrackDedicatedServerError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVrackDedicatedServerRequest,
+  output: VrackDedicatedServer,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVrackDedicatedServerInterfaceError = OvhOpError;
+/** Get this object properties */
+export const getVrackDedicatedServerInterface: API.OperationMethod<
+  GetVrackDedicatedServerInterfaceRequest,
+  VrackDedicatedServerInterface,
+  GetVrackDedicatedServerInterfaceError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVrackDedicatedServerInterfaceRequest,
+  output: VrackDedicatedServerInterface,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVrackIpError = OvhOpError;
+/** Get this object properties */
+export const getVrackIp: API.OperationMethod<
+  GetVrackIpRequest,
+  VrackIp,
+  GetVrackIpError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVrackIpRequest,
+  output: VrackIp,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVrackIpLoadbalancingError = OvhOpError;
+/** Get this object properties */
+export const getVrackIpLoadbalancing: API.OperationMethod<
+  GetVrackIpLoadbalancingRequest,
+  VrackIplb,
+  GetVrackIpLoadbalancingError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVrackIpLoadbalancingRequest,
+  output: VrackIplb,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVrackIpv6Error = OvhOpError;
+/** Get this object properties */
+export const getVrackIpv6: API.OperationMethod<
+  GetVrackIpv6Request,
+  VrackIpv6,
+  GetVrackIpv6Error,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVrackIpv6Request,
+  output: VrackIpv6,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVrackIpv6BridgedSubrangeError = OvhOpError;
+/** Get this object properties */
+export const getVrackIpv6BridgedSubrange: API.OperationMethod<
+  GetVrackIpv6BridgedSubrangeRequest,
+  VrackBridgedSubrange,
+  GetVrackIpv6BridgedSubrangeError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVrackIpv6BridgedSubrangeRequest,
+  output: VrackBridgedSubrange,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVrackIpv6RoutedSubrangeError = OvhOpError;
+/** Get this object properties */
+export const getVrackIpv6RoutedSubrange: API.OperationMethod<
+  GetVrackIpv6RoutedSubrangeRequest,
+  VrackRoutedSubrange,
+  GetVrackIpv6RoutedSubrangeError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVrackIpv6RoutedSubrangeRequest,
+  output: VrackRoutedSubrange,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVrackLegacyVrackError = OvhOpError;
+/** Get this object properties */
+export const getVrackLegacyVrack: API.OperationMethod<
+  GetVrackLegacyVrackRequest,
+  VrackLegacyVrack,
+  GetVrackLegacyVrackError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVrackLegacyVrackRequest,
+  output: VrackLegacyVrack,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVrackOvhCloudConnectError = OvhOpError;
+/** Get this object properties */
+export const getVrackOvhCloudConnect: API.OperationMethod<
+  GetVrackOvhCloudConnectRequest,
+  VrackOvhCloudConnect,
+  GetVrackOvhCloudConnectError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVrackOvhCloudConnectRequest,
+  output: VrackOvhCloudConnect,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVrackPublicRoutingOptionError = OvhOpError;
+/** Information on public routing option */
+export const getVrackPublicRoutingOption: API.OperationMethod<
+  GetVrackPublicRoutingOptionRequest,
+  VrackPublicRoutingOption,
+  GetVrackPublicRoutingOptionError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVrackPublicRoutingOptionRequest,
+  output: VrackPublicRoutingOption,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVrackServiceInfosError = OvhOpError;
+/** Get this object properties */
+export const getVrackServiceInfos: API.OperationMethod<
+  GetVrackServiceInfosRequest,
+  ServicesNonExpiringService,
+  GetVrackServiceInfosError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVrackServiceInfosRequest,
+  output: ServicesNonExpiringService,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVrackTaskError = OvhOpError;
+/** Get this object properties */
+export const getVrackTask: API.OperationMethod<
+  GetVrackTaskRequest,
+  VrackTask,
+  GetVrackTaskError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVrackTaskRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVrackVmwareCloudDirectorVirtualDataCenterError = OvhOpError;
+/** Get this object properties */
+export const getVrackVmwareCloudDirectorVirtualDataCenter: API.OperationMethod<
+  GetVrackVmwareCloudDirectorVirtualDataCenterRequest,
+  VrackVmwareCloudDirectorVirtualDataCenter,
+  GetVrackVmwareCloudDirectorVirtualDataCenterError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVrackVmwareCloudDirectorVirtualDataCenterRequest,
+  output: VrackVmwareCloudDirectorVirtualDataCenter,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVrackVrackServiceError = OvhOpError;
+/** Get this object properties */
+export const getVrackVrackService: API.OperationMethod<
+  GetVrackVrackServiceRequest,
+  VrackVrackServices,
+  GetVrackVrackServiceError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVrackVrackServiceRequest,
+  output: VrackVrackServices,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackError = OvhOpError;
+/** List available services */
+export const listVrack: API.OperationMethod<
+  ListVrackRequest,
+  ListVrackResponse,
+  ListVrackError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackRequest,
+  output: ListVrackResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackAllowedServicesError = OvhOpError;
+/** List all services allowed in this vrack */
+export const listVrackAllowedServices: API.OperationMethod<
+  ListVrackAllowedServicesRequest,
+  VrackAllowedServices,
+  ListVrackAllowedServicesError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackAllowedServicesRequest,
+  output: VrackAllowedServices,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackCloudProjectError = OvhOpError;
+/** vrack for publicCloud project */
+export const listVrackCloudProject: API.OperationMethod<
+  ListVrackCloudProjectRequest,
+  ListVrackCloudProjectResponse,
+  ListVrackCloudProjectError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackCloudProjectRequest,
+  output: ListVrackCloudProjectResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackDedicatedCloudError = OvhOpError;
+/** vrack dedicated cloud (VmNetwork) */
+export const listVrackDedicatedCloud: API.OperationMethod<
+  ListVrackDedicatedCloudRequest,
+  ListVrackDedicatedCloudResponse,
+  ListVrackDedicatedCloudError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackDedicatedCloudRequest,
+  output: ListVrackDedicatedCloudResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackDedicatedCloudDatacenterError = OvhOpError;
+/** vrack dedicated cloud datacenter */
+export const listVrackDedicatedCloudDatacenter: API.OperationMethod<
+  ListVrackDedicatedCloudDatacenterRequest,
+  ListVrackDedicatedCloudDatacenterResponse,
+  ListVrackDedicatedCloudDatacenterError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackDedicatedCloudDatacenterRequest,
+  output: ListVrackDedicatedCloudDatacenterResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackDedicatedCloudDatacenterAllowedVrackError = OvhOpError;
+/** Vracks allowed for your dedicatedCloud datacenter */
+export const listVrackDedicatedCloudDatacenterAllowedVrack: API.OperationMethod<
+  ListVrackDedicatedCloudDatacenterAllowedVrackRequest,
+  ListVrackDedicatedCloudDatacenterAllowedVrackResponse,
+  ListVrackDedicatedCloudDatacenterAllowedVrackError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackDedicatedCloudDatacenterAllowedVrackRequest,
+  output: ListVrackDedicatedCloudDatacenterAllowedVrackResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackDedicatedConnectError = OvhOpError;
+/** vrack dedicated connect */
+export const listVrackDedicatedConnect: API.OperationMethod<
+  ListVrackDedicatedConnectRequest,
+  ListVrackDedicatedConnectResponse,
+  ListVrackDedicatedConnectError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackDedicatedConnectRequest,
+  output: ListVrackDedicatedConnectResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackDedicatedServerError = OvhOpError;
+/** vrack for dedicated server */
+export const listVrackDedicatedServer: API.OperationMethod<
+  ListVrackDedicatedServerRequest,
+  ListVrackDedicatedServerResponse,
+  ListVrackDedicatedServerError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackDedicatedServerRequest,
+  output: ListVrackDedicatedServerResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackDedicatedServerInterfaceError = OvhOpError;
+/** vrack for dedicated server interface */
+export const listVrackDedicatedServerInterface: API.OperationMethod<
+  ListVrackDedicatedServerInterfaceRequest,
+  ListVrackDedicatedServerInterfaceResponse,
+  ListVrackDedicatedServerInterfaceError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackDedicatedServerInterfaceRequest,
+  output: ListVrackDedicatedServerInterfaceResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackDedicatedServerInterfaceDetailsError = OvhOpError;
+/** Details for all dedicated server interfaces in this vrack */
+export const listVrackDedicatedServerInterfaceDetails: API.OperationMethod<
+  ListVrackDedicatedServerInterfaceDetailsRequest,
+  ListVrackDedicatedServerInterfaceDetailsResponse,
+  ListVrackDedicatedServerInterfaceDetailsError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackDedicatedServerInterfaceDetailsRequest,
+  output: ListVrackDedicatedServerInterfaceDetailsResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackEligibleServicesError = OvhOpError;
+/** List all eligible services for this vRack asynchronously This route allows asynchronous service eligibility requests. It means the route can be called several times until all the eligible services are returned. While the `status` is set to `pending` the results are partial. Once the `status` is set to `done`, all the eligible services have been found. In the eventuality of errors getting specific service types, the errors will be listed in the `errors` field. */
+export const listVrackEligibleServices: API.OperationMethod<
+  ListVrackEligibleServicesRequest,
+  VrackEligibleServicesResponse,
+  ListVrackEligibleServicesError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackEligibleServicesRequest,
+  output: VrackEligibleServicesResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackIpError = OvhOpError;
+/** vrack for IP blocks */
+export const listVrackIp: API.OperationMethod<
+  ListVrackIpRequest,
+  ListVrackIpResponse,
+  ListVrackIpError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackIpRequest,
+  output: ListVrackIpResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackIpLoadbalancingError = OvhOpError;
+/** vrack for ipLoadbalancing */
+export const listVrackIpLoadbalancing: API.OperationMethod<
+  ListVrackIpLoadbalancingRequest,
+  ListVrackIpLoadbalancingResponse,
+  ListVrackIpLoadbalancingError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackIpLoadbalancingRequest,
+  output: ListVrackIpLoadbalancingResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackIpv6Error = OvhOpError;
+/** vrack for IP v6 blocks */
+export const listVrackIpv6: API.OperationMethod<
+  ListVrackIpv6Request,
+  ListVrackIpv6Response,
+  ListVrackIpv6Error,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackIpv6Request,
+  output: ListVrackIpv6Response,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackIpv6BridgedSubrangeError = OvhOpError;
+/** subrange bridged into your vrack */
+export const listVrackIpv6BridgedSubrange: API.OperationMethod<
+  ListVrackIpv6BridgedSubrangeRequest,
+  ListVrackIpv6BridgedSubrangeResponse,
+  ListVrackIpv6BridgedSubrangeError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackIpv6BridgedSubrangeRequest,
+  output: ListVrackIpv6BridgedSubrangeResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackIpv6RoutedSubrangeError = OvhOpError;
+/** subrange routed into your vrack */
+export const listVrackIpv6RoutedSubrange: API.OperationMethod<
+  ListVrackIpv6RoutedSubrangeRequest,
+  ListVrackIpv6RoutedSubrangeResponse,
+  ListVrackIpv6RoutedSubrangeError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackIpv6RoutedSubrangeRequest,
+  output: ListVrackIpv6RoutedSubrangeResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackLegacyVrackError = OvhOpError;
+/** vrack for legacy vrack */
+export const listVrackLegacyVrack: API.OperationMethod<
+  ListVrackLegacyVrackRequest,
+  ListVrackLegacyVrackResponse,
+  ListVrackLegacyVrackError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackLegacyVrackRequest,
+  output: ListVrackLegacyVrackResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackOvhCloudConnectError = OvhOpError;
+/** vrack for ovhCloudConnect */
+export const listVrackOvhCloudConnect: API.OperationMethod<
+  ListVrackOvhCloudConnectRequest,
+  ListVrackOvhCloudConnectResponse,
+  ListVrackOvhCloudConnectError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackOvhCloudConnectRequest,
+  output: ListVrackOvhCloudConnectResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackTaskError = OvhOpError;
+/** vrack tasks */
+export const listVrackTask: API.OperationMethod<
+  ListVrackTaskRequest,
+  ListVrackTaskResponse,
+  ListVrackTaskError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackTaskRequest,
+  output: ListVrackTaskResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackVmwareCloudDirectorVirtualDataCenterError = OvhOpError;
+/** vrack for vmwareCloudDirectorVirtualDataCenter */
+export const listVrackVmwareCloudDirectorVirtualDataCenter: API.OperationMethod<
+  ListVrackVmwareCloudDirectorVirtualDataCenterRequest,
+  ListVrackVmwareCloudDirectorVirtualDataCenterResponse,
+  ListVrackVmwareCloudDirectorVirtualDataCenterError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackVmwareCloudDirectorVirtualDataCenterRequest,
+  output: ListVrackVmwareCloudDirectorVirtualDataCenterResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackVrackServicesError = OvhOpError;
+/** vrack for vrackServices */
+export const listVrackVrackServices: API.OperationMethod<
+  ListVrackVrackServicesRequest,
+  ListVrackVrackServicesResponse,
+  ListVrackVrackServicesError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackVrackServicesRequest,
+  output: ListVrackVrackServicesResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type MoveVrackDedicatedCloudDatacenterError = OvhOpError;
+/** Move your dedicatedCloud datacenter from a Vrack to another */
+export const moveVrackDedicatedCloudDatacenter: API.OperationMethod<
+  MoveVrackDedicatedCloudDatacenterRequest,
+  VrackTask,
+  MoveVrackDedicatedCloudDatacenterError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: MoveVrackDedicatedCloudDatacenterRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutVrackError = OvhOpError;
+/** Alter this object properties */
+export const putVrack: API.OperationMethod<
+  PutVrackRequest,
+  PutVrackResponse,
+  PutVrackError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutVrackRequest,
+  output: PutVrackResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutVrackDedicatedConnectError = OvhOpError;
+/** Alter this object properties */
+export const putVrackDedicatedConnect: API.OperationMethod<
+  PutVrackDedicatedConnectRequest,
+  PutVrackDedicatedConnectResponse,
+  PutVrackDedicatedConnectError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutVrackDedicatedConnectRequest,
+  output: PutVrackDedicatedConnectResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutVrackIpv6BridgedSubrangeError = OvhOpError;
+/** Update Slaac status */
+export const putVrackIpv6BridgedSubrange: API.OperationMethod<
+  PutVrackIpv6BridgedSubrangeRequest,
+  VrackTask,
+  PutVrackIpv6BridgedSubrangeError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutVrackIpv6BridgedSubrangeRequest,
+  output: VrackTask,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type TerminateVrackError = 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 terminateVrack: API.OperationMethod<
+  TerminateVrackRequest,
+  TerminateVrackResponse,
+  TerminateVrackError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: TerminateVrackRequest,
+  output: TerminateVrackResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));