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

package/src/services/vrackservices.ts

@@ -0,0 +1,939 @@
+// 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 C from "@distilled.cloud/core/category";
+import * as T from "../traits.ts";
+import {
+  OvhProtocol,
+  type OvhOpError,
+  type OvhOpContext,
+} from "../protocol.ts";
+import { UnknownOvhError } from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { OvhOpError, OvhOpContext };
+
+export class BadRequest
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<BadRequest>()("BadRequest", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withBadRequestError),
+    [{ status: 400 }],
+  ) {}
+
+export class NotFound
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<NotFound>()("NotFound", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withBadRequestError),
+    [{ status: 404 }],
+  ) {}
+
+export interface GetVrackServiceResourceRequest {
+  /** Vrack services ID */
+  vrackServicesId: string;
+}
+export const GetVrackServiceResourceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    vrackServicesId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrackServices/resource/{vrackServicesId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetVrackServiceResourceRequest",
+}) as any as S.Schema<GetVrackServiceResourceRequest>;
+
+/** ProductStatusEnum */
+export type VrackServicesProductStatusEnum = "ACTIVE" | "DRAFT" | "SUSPENDED";
+export const VrackServicesProductStatusEnum = S.String;
+
+/** Endpoint holding a managed service IP */
+export interface VrackServicesEndpoint {
+  /** IP description defined in the managed service */
+  description?: string;
+  /** IP address assigned by OVHcloud */
+  ip?: string;
+}
+export const VrackServicesEndpoint = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    description: S.optional(S.String),
+    ip: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "VrackServicesEndpoint",
+}) as any as S.Schema<VrackServicesEndpoint>;
+
+/** Endpoints representing the IPs assigned to the managed services */
+export type VrackServicesServiceEndpointEndpointsList =
+  Array<VrackServicesEndpoint>;
+export const VrackServicesServiceEndpointEndpointsList = /*@__PURE__*/ S.Array(
+  VrackServicesEndpoint,
+) as any as S.Schema<VrackServicesServiceEndpointEndpointsList>;
+
+/** A Service Endpoint provides an access to managed services directly from one or several private IPs in the associated vRack */
+export interface VrackServicesServiceEndpoint {
+  /** Endpoints representing the IPs assigned to the managed services */
+  endpoints?: VrackServicesServiceEndpointEndpointsList;
+  /** IAM Resource URN of the managed service. Compatible managed service types are listed by /reference/compatibleManagedServiceType call. */
+  managedServiceURN?: string;
+}
+export const VrackServicesServiceEndpoint = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    endpoints: S.optional(VrackServicesServiceEndpointEndpointsList),
+    managedServiceURN: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "VrackServicesServiceEndpoint",
+}) as any as S.Schema<VrackServicesServiceEndpoint>;
+
+/** Service endpoints of the subnet */
+export type VrackServicesSubnetServiceEndpointsList =
+  Array<VrackServicesServiceEndpoint>;
+export const VrackServicesSubnetServiceEndpointsList = /*@__PURE__*/ S.Array(
+  VrackServicesServiceEndpoint,
+) as any as S.Schema<VrackServicesSubnetServiceEndpointsList>;
+
+/** Definition of the range dedicated to the subnet's services */
+export interface VrackServicesServiceRange {
+  /** CIDR dedicated to the subnet's services */
+  cidr?: string;
+  /** Number of remaining IPs in the service range */
+  remainingIps?: number;
+  /** Number of service range IPs reserved by OVHcloud */
+  reservedIps?: number;
+  /** Number of service range IPs assigned to the managed services */
+  usedIps?: number;
+}
+export const VrackServicesServiceRange = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cidr: S.optional(S.String),
+    remainingIps: S.optional(S.Number),
+    reservedIps: S.optional(S.Number),
+    usedIps: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "VrackServicesServiceRange",
+}) as any as S.Schema<VrackServicesServiceRange>;
+
+/** A network segment of the associated vRack. It represents an IP addressing scheme inside the private network */
+export interface VrackServicesSubnet {
+  /** IP address range of the subnet in CIDR format */
+  cidr?: string;
+  /** Display name of the subnet */
+  displayName?: string | null;
+  /** Service endpoints of the subnet */
+  serviceEndpoints?: VrackServicesSubnetServiceEndpointsList;
+  /** Defines a smaller subnet dedicated to the managed services IPs */
+  serviceRange?: VrackServicesServiceRange;
+  /** Unique inner VLAN that allows subnets segregation */
+  vlan?: number | null;
+}
+export const VrackServicesSubnet = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cidr: S.optional(S.String),
+    displayName: S.optional(S.NullOr(S.String)),
+    serviceEndpoints: S.optional(VrackServicesSubnetServiceEndpointsList),
+    serviceRange: S.optional(VrackServicesServiceRange),
+    vlan: S.optional(S.NullOr(S.Number)),
+  }),
+).annotate({
+  identifier: "VrackServicesSubnet",
+}) as any as S.Schema<VrackServicesSubnet>;
+
+/** Subnets of the current vRack Services */
+export type VrackServicesVrackServicesCurrentStateSubnetsList =
+  Array<VrackServicesSubnet>;
+export const VrackServicesVrackServicesCurrentStateSubnetsList =
+  /*@__PURE__*/ S.Array(
+    VrackServicesSubnet,
+  ) as any as S.Schema<VrackServicesVrackServicesCurrentStateSubnetsList>;
+
+/** Current state of the vRack Services */
+export interface VrackServicesVrackServicesCurrentState {
+  /** Product status of the vRack Services */
+  productStatus?: VrackServicesProductStatusEnum;
+  /** Region of the vRack Services. List of compatible regions can be retrieved from /reference/region */
+  region?: string;
+  /** Subnets of the current vRack Services */
+  subnets?: VrackServicesVrackServicesCurrentStateSubnetsList;
+  /** vRack associated to the vRack Services */
+  vrackId?: string | null;
+}
+export const VrackServicesVrackServicesCurrentState = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      productStatus: S.optional(VrackServicesProductStatusEnum),
+      region: S.optional(S.String),
+      subnets: S.optional(VrackServicesVrackServicesCurrentStateSubnetsList),
+      vrackId: S.optional(S.NullOr(S.String)),
+    }),
+).annotate({
+  identifier: "VrackServicesVrackServicesCurrentState",
+}) as any as S.Schema<VrackServicesVrackServicesCurrentState>;
+
+/** Current status of a task. A task in ERROR cannot be retried without your inputs. PENDING tasks will be executed as soon as possible. A RUNNING task is currently executing your original request. SCHEDULED is used for tasks that will be executed in the future */
+export type CommonCurrentTaskStatusEnum =
+  | "ERROR"
+  | "PENDING"
+  | "RUNNING"
+  | "SCHEDULED";
+export const CommonCurrentTaskStatusEnum = S.String;
+
+/** Asynchronous operation currently running */
+export interface CommonCurrentTask {
+  /** Identifier of the current task */
+  id?: string;
+  /** Link to the task details */
+  link?: string;
+  /** Current global status of the current task */
+  status?: CommonCurrentTaskStatusEnum | null;
+  /** Type of the current task */
+  type?: string;
+}
+export const CommonCurrentTask = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.optional(S.String),
+    link: S.optional(S.String),
+    status: S.optional(S.NullOr(CommonCurrentTaskStatusEnum)),
+    type: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "CommonCurrentTask",
+}) as any as S.Schema<CommonCurrentTask>;
+
+/** Asynchronous operations ongoing on the vRack Services */
+export type VrackServicesVrackServicesWithIAMCurrentTasksList =
+  Array<CommonCurrentTask>;
+export const VrackServicesVrackServicesWithIAMCurrentTasksList =
+  /*@__PURE__*/ S.Array(
+    CommonCurrentTask,
+  ) as any as S.Schema<VrackServicesVrackServicesWithIAMCurrentTasksList>;
+
+/** 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>;
+
+/** It reflects the readiness of the vRack Services resource. The status `READY` indicates that the vRack Services state is stable. It guarantees that the `currentState` is fully aligned with the `targetSpec`. A new target specification request will be accepted only in this status. */
+export type VrackServicesResourceStatusEnum =
+  | "CREATING"
+  | "DELETING"
+  | "ERROR"
+  | "READY"
+  | "UPDATING";
+export const VrackServicesResourceStatusEnum = S.String;
+
+/** Target specification of a Service Endpoint. A Service Endpoint provides an access to a managed service directly from one or several private IPs in the associated vRack */
+export interface VrackServicesTargetServiceEndpoint {
+  /** IAM Resource URN of the managed service. Managed service Region must match vRack Services Region. Compatible managed service types are listed by /reference/compatibleManagedServiceType call */
+  managedServiceURN: string;
+}
+export const VrackServicesTargetServiceEndpoint = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    managedServiceURN: S.String,
+  }),
+).annotate({
+  identifier: "VrackServicesTargetServiceEndpoint",
+}) as any as S.Schema<VrackServicesTargetServiceEndpoint>;
+
+/** Target specification of the Service Endpoints */
+export type VrackServicesTargetSubnetServiceEndpointsList =
+  Array<VrackServicesTargetServiceEndpoint>;
+export const VrackServicesTargetSubnetServiceEndpointsList =
+  /*@__PURE__*/ S.Array(
+    VrackServicesTargetServiceEndpoint,
+  ) as any as S.Schema<VrackServicesTargetSubnetServiceEndpointsList>;
+
+/** Target specification of the range dedicated to the subnet's services */
+export interface VrackServicesTargetServiceRange {
+  /** IP address range dedicated to the subnet's services in CIDR format. Must be a private network address (RFC1918). Must be a sub-network of the subnet. Authorized range for prefix length: /27 to /29 */
+  cidr: string;
+}
+export const VrackServicesTargetServiceRange = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cidr: S.String,
+  }),
+).annotate({
+  identifier: "VrackServicesTargetServiceRange",
+}) as any as S.Schema<VrackServicesTargetServiceRange>;
+
+/** Target specification of a subnet */
+export interface VrackServicesTargetSubnet {
+  /** IP address range of the subnet in CIDR format. Must be a private network address (RFC1918). Authorized range for prefix length: /16 to /24 */
+  cidr: string;
+  /** Display name of the subnet. Format must follow `^[ a-zA-Z0-9-_.]{0,40}$` */
+  displayName?: string | null;
+  /** Target specification of the Service Endpoints */
+  serviceEndpoints: VrackServicesTargetSubnetServiceEndpointsList;
+  /** Defines a smaller subnet dedicated to the managed service IPs */
+  serviceRange: VrackServicesTargetServiceRange;
+  /** Unique inner VLAN that allows subnets segregation. Authorized values: [2 - 4094] and `null` (untagged traffic) */
+  vlan?: number | null;
+}
+export const VrackServicesTargetSubnet = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cidr: S.String,
+    displayName: S.optional(S.NullOr(S.String)),
+    serviceEndpoints: VrackServicesTargetSubnetServiceEndpointsList,
+    serviceRange: VrackServicesTargetServiceRange,
+    vlan: S.optional(S.NullOr(S.Number)),
+  }),
+).annotate({
+  identifier: "VrackServicesTargetSubnet",
+}) as any as S.Schema<VrackServicesTargetSubnet>;
+
+/** Target specification of the subnets. Maximum one subnet per vRack Services */
+export type VrackServicesVrackServicesTargetSpecSubnetsList =
+  Array<VrackServicesTargetSubnet>;
+export const VrackServicesVrackServicesTargetSpecSubnetsList =
+  /*@__PURE__*/ S.Array(
+    VrackServicesTargetSubnet,
+  ) as any as S.Schema<VrackServicesVrackServicesTargetSpecSubnetsList>;
+
+/** Target specification of the vRack Services */
+export interface VrackServicesVrackServicesTargetSpec {
+  /** Target specification of the subnets. Maximum one subnet per vRack Services */
+  subnets: VrackServicesVrackServicesTargetSpecSubnetsList;
+}
+export const VrackServicesVrackServicesTargetSpec = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      subnets: VrackServicesVrackServicesTargetSpecSubnetsList,
+    }),
+).annotate({
+  identifier: "VrackServicesVrackServicesTargetSpec",
+}) as any as S.Schema<VrackServicesVrackServicesTargetSpec>;
+
+/** A vRack Services */
+export interface VrackServicesVrackServicesWithIAM {
+  /** Computed hash used to control concurrent modification requests. Here, it represents the current target specification value */
+  checksum?: string;
+  /** Date of the vRack Services delivery */
+  createdAt?: string;
+  /** Current configuration applied to the vRack Services */
+  currentState?: VrackServicesVrackServicesCurrentState;
+  /** Asynchronous operations ongoing on the vRack Services */
+  currentTasks?: VrackServicesVrackServicesWithIAMCurrentTasksList | null;
+  /** IAM resource metadata */
+  iam?: IamResourceMetadata | null;
+  /** Unique identifier */
+  id?: string;
+  /** Reflects the readiness of the vRack Services. A new target specification request will be accepted only in `READY` status */
+  resourceStatus?: VrackServicesResourceStatusEnum;
+  /** Last target specification of the vRack Services */
+  targetSpec?: VrackServicesVrackServicesTargetSpec;
+  /** Date of the Last vRack Services update */
+  updatedAt?: string;
+}
+export const VrackServicesVrackServicesWithIAM = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    checksum: S.optional(S.String),
+    createdAt: S.optional(S.String),
+    currentState: S.optional(VrackServicesVrackServicesCurrentState),
+    currentTasks: S.optional(
+      S.NullOr(VrackServicesVrackServicesWithIAMCurrentTasksList),
+    ),
+    iam: S.optional(S.NullOr(IamResourceMetadata)),
+    id: S.optional(S.String),
+    resourceStatus: S.optional(VrackServicesResourceStatusEnum),
+    targetSpec: S.optional(VrackServicesVrackServicesTargetSpec),
+    updatedAt: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "VrackServicesVrackServicesWithIAM",
+}) as any as S.Schema<VrackServicesVrackServicesWithIAM>;
+
+export interface GetVrackServiceResourceTaskRequest {
+  /** Vrack services ID */
+  vrackServicesId: string;
+  /** Task ID */
+  taskId: string;
+}
+export const GetVrackServiceResourceTaskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    vrackServicesId: S.String.pipe(T.Label()),
+    taskId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrackServices/resource/{vrackServicesId}/task/{taskId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetVrackServiceResourceTaskRequest",
+}) as any as S.Schema<GetVrackServiceResourceTaskRequest>;
+
+/** Errors that occured on the task */
+export interface CommonTaskError {
+  /** Error description */
+  message?: string;
+}
+export const CommonTaskError = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    message: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "CommonTaskError",
+}) as any as S.Schema<CommonTaskError>;
+
+/** Errors that occured on the task */
+export type CommonTaskErrorsList = Array<CommonTaskError>;
+export const CommonTaskErrorsList = /*@__PURE__*/ S.Array(
+  CommonTaskError,
+) as any as S.Schema<CommonTaskErrorsList>;
+
+/** TaskStatusEnum */
+export type CommonTaskStatusEnum =
+  | "DONE"
+  | "ERROR"
+  | "PENDING"
+  | "RUNNING"
+  | "SCHEDULED";
+export const CommonTaskStatusEnum = S.String;
+
+/** Detailed information about an asynchronous operation progress steps */
+export interface CommonTaskProgress {
+  /** Progress step name */
+  name?: string;
+  /** Current status of the progress step */
+  status?: CommonTaskStatusEnum;
+}
+export const CommonTaskProgress = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.optional(S.String),
+    status: S.optional(CommonTaskStatusEnum),
+  }),
+).annotate({
+  identifier: "CommonTaskProgress",
+}) as any as S.Schema<CommonTaskProgress>;
+
+/** Progress steps of the asynchronous operation */
+export type CommonTaskProgressList = Array<CommonTaskProgress>;
+export const CommonTaskProgressList = /*@__PURE__*/ S.Array(
+  CommonTaskProgress,
+) as any as S.Schema<CommonTaskProgressList>;
+
+/** Asynchronous operation */
+export interface CommonTask {
+  /** Creation date of the task */
+  createdAt?: string;
+  /** Errors that occured on the task */
+  errors?: CommonTaskErrorsList | null;
+  /** Ending date of the task */
+  finishedAt?: string | null;
+  /** Identifier of the task */
+  id?: string;
+  /** Link to the related resource */
+  link?: string;
+  /** Description of the task */
+  message?: string;
+  /** Progress steps of the asynchronous operation */
+  progress?: CommonTaskProgressList;
+  /** Starting date of the task */
+  startedAt?: string | null;
+  /** Current global status of the task */
+  status?: CommonTaskStatusEnum;
+  /** Type of the task */
+  type?: string;
+  /** Last update of the task */
+  updatedAt?: string;
+}
+export const CommonTask = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    createdAt: S.optional(S.String),
+    errors: S.optional(S.NullOr(CommonTaskErrorsList)),
+    finishedAt: S.optional(S.NullOr(S.String)),
+    id: S.optional(S.String),
+    link: S.optional(S.String),
+    message: S.optional(S.String),
+    progress: S.optional(CommonTaskProgressList),
+    startedAt: S.optional(S.NullOr(S.String)),
+    status: S.optional(CommonTaskStatusEnum),
+    type: S.optional(S.String),
+    updatedAt: S.optional(S.String),
+  }),
+).annotate({ identifier: "CommonTask" }) as any as S.Schema<CommonTask>;
+
+export interface ListVrackServiceReferenceCompatibleManagedServiceTypeRequest {
+  /** Pagination cursor */
+  xPaginationCursor?: string;
+  /** Pagination size */
+  xPaginationSize?: number;
+}
+export const ListVrackServiceReferenceCompatibleManagedServiceTypeRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      xPaginationCursor: S.optional(
+        S.String.pipe(T.Header("X-Pagination-Cursor")),
+      ),
+      xPaginationSize: S.optional(S.Number.pipe(T.Header("X-Pagination-Size"))),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/vrackServices/reference/compatibleManagedServiceType",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListVrackServiceReferenceCompatibleManagedServiceTypeRequest",
+  }) as any as S.Schema<ListVrackServiceReferenceCompatibleManagedServiceTypeRequest>;
+
+export type ListVrackServiceReferenceCompatibleManagedServiceTypeResponseBodyList =
+  Array<string>;
+export const ListVrackServiceReferenceCompatibleManagedServiceTypeResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListVrackServiceReferenceCompatibleManagedServiceTypeResponseBodyList>;
+
+export type ListVrackServiceReferenceCompatibleManagedServiceTypeResponse =
+  ListVrackServiceReferenceCompatibleManagedServiceTypeResponseBodyList;
+export const ListVrackServiceReferenceCompatibleManagedServiceTypeResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListVrackServiceReferenceCompatibleManagedServiceTypeResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListVrackServiceReferenceCompatibleManagedServiceTypeResponse",
+  }) as any as S.Schema<ListVrackServiceReferenceCompatibleManagedServiceTypeResponse>;
+
+export interface ListVrackServiceReferenceRegionRequest {
+  /** Pagination cursor */
+  xPaginationCursor?: string;
+  /** Pagination size */
+  xPaginationSize?: number;
+}
+export const ListVrackServiceReferenceRegionRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      xPaginationCursor: S.optional(
+        S.String.pipe(T.Header("X-Pagination-Cursor")),
+      ),
+      xPaginationSize: S.optional(S.Number.pipe(T.Header("X-Pagination-Size"))),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/vrackServices/reference/region",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListVrackServiceReferenceRegionRequest",
+}) as any as S.Schema<ListVrackServiceReferenceRegionRequest>;
+
+/** A vRack Services compatible localization */
+export interface VrackServicesRegion {
+  /** Region name */
+  name?: string;
+}
+export const VrackServicesRegion = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "VrackServicesRegion",
+}) as any as S.Schema<VrackServicesRegion>;
+
+export type ListVrackServiceReferenceRegionResponseBodyList =
+  Array<VrackServicesRegion>;
+export const ListVrackServiceReferenceRegionResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    VrackServicesRegion,
+  ) as any as S.Schema<ListVrackServiceReferenceRegionResponseBodyList>;
+
+export type ListVrackServiceReferenceRegionResponse =
+  ListVrackServiceReferenceRegionResponseBodyList;
+export const ListVrackServiceReferenceRegionResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    ListVrackServiceReferenceRegionResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListVrackServiceReferenceRegionResponse",
+}) as any as S.Schema<ListVrackServiceReferenceRegionResponse>;
+
+/** 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 ListVrackServiceResourceRequestIamTagsValueList =
+  Array<IamResourceTagFilterInput>;
+export const ListVrackServiceResourceRequestIamTagsValueList =
+  /*@__PURE__*/ S.Array(
+    IamResourceTagFilterInput,
+  ) as any as S.Schema<ListVrackServiceResourceRequestIamTagsValueList>;
+
+export type ListVrackServiceResourceRequestIamTagsMap = {
+  [key: string]: ListVrackServiceResourceRequestIamTagsValueList | undefined;
+};
+export const ListVrackServiceResourceRequestIamTagsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  ListVrackServiceResourceRequestIamTagsValueList,
+) as any as S.Schema<ListVrackServiceResourceRequestIamTagsMap>;
+
+export interface ListVrackServiceResourceRequest {
+  /** Filter resources on IAM tags */
+  iamTags?: ListVrackServiceResourceRequestIamTagsMap;
+  /** Pagination cursor */
+  xPaginationCursor?: string;
+  /** Pagination size */
+  xPaginationSize?: number;
+}
+export const ListVrackServiceResourceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    iamTags: S.optional(
+      ListVrackServiceResourceRequestIamTagsMap.pipe(T.Query()),
+    ),
+    xPaginationCursor: S.optional(
+      S.String.pipe(T.Header("X-Pagination-Cursor")),
+    ),
+    xPaginationSize: S.optional(S.Number.pipe(T.Header("X-Pagination-Size"))),
+  }).pipe(T.Http({ method: "GET", uri: "/vrackServices/resource", code: 200 })),
+).annotate({
+  identifier: "ListVrackServiceResourceRequest",
+}) as any as S.Schema<ListVrackServiceResourceRequest>;
+
+export type ListVrackServiceResourceResponseBodyList =
+  Array<VrackServicesVrackServicesWithIAM>;
+export const ListVrackServiceResourceResponseBodyList = /*@__PURE__*/ S.Array(
+  VrackServicesVrackServicesWithIAM,
+) as any as S.Schema<ListVrackServiceResourceResponseBodyList>;
+
+export type ListVrackServiceResourceResponse =
+  ListVrackServiceResourceResponseBodyList;
+export const ListVrackServiceResourceResponse = /*@__PURE__*/ S.suspend(() =>
+  ListVrackServiceResourceResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListVrackServiceResourceResponse",
+}) as any as S.Schema<ListVrackServiceResourceResponse>;
+
+export interface ListVrackServiceResourceEligibleManagedServiceRequest {
+  /** Vrack services ID */
+  vrackServicesId: string;
+  /** Pagination cursor */
+  xPaginationCursor?: string;
+  /** Pagination size */
+  xPaginationSize?: number;
+}
+export const ListVrackServiceResourceEligibleManagedServiceRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      vrackServicesId: S.String.pipe(T.Label()),
+      xPaginationCursor: S.optional(
+        S.String.pipe(T.Header("X-Pagination-Cursor")),
+      ),
+      xPaginationSize: S.optional(S.Number.pipe(T.Header("X-Pagination-Size"))),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/vrackServices/resource/{vrackServicesId}/eligibleManagedService",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListVrackServiceResourceEligibleManagedServiceRequest",
+  }) as any as S.Schema<ListVrackServiceResourceEligibleManagedServiceRequest>;
+
+/** List of IAM resource URNs */
+export type VrackServicesEligibleManagedServiceManagedServiceURNsList =
+  Array<string>;
+export const VrackServicesEligibleManagedServiceManagedServiceURNsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<VrackServicesEligibleManagedServiceManagedServiceURNsList>;
+
+/** List of managed services eligible to the requested vRack Services */
+export interface VrackServicesEligibleManagedService {
+  /** IAM resource type. Compatible managed service types are listed by /reference/compatibleManagedServiceType call. */
+  managedServiceType?: string;
+  /** List of IAM resource URNs */
+  managedServiceURNs?: VrackServicesEligibleManagedServiceManagedServiceURNsList;
+}
+export const VrackServicesEligibleManagedService = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    managedServiceType: S.optional(S.String),
+    managedServiceURNs: S.optional(
+      VrackServicesEligibleManagedServiceManagedServiceURNsList,
+    ),
+  }),
+).annotate({
+  identifier: "VrackServicesEligibleManagedService",
+}) as any as S.Schema<VrackServicesEligibleManagedService>;
+
+export type ListVrackServiceResourceEligibleManagedServiceResponseBodyList =
+  Array<VrackServicesEligibleManagedService>;
+export const ListVrackServiceResourceEligibleManagedServiceResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    VrackServicesEligibleManagedService,
+  ) as any as S.Schema<ListVrackServiceResourceEligibleManagedServiceResponseBodyList>;
+
+export type ListVrackServiceResourceEligibleManagedServiceResponse =
+  ListVrackServiceResourceEligibleManagedServiceResponseBodyList;
+export const ListVrackServiceResourceEligibleManagedServiceResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListVrackServiceResourceEligibleManagedServiceResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListVrackServiceResourceEligibleManagedServiceResponse",
+  }) as any as S.Schema<ListVrackServiceResourceEligibleManagedServiceResponse>;
+
+export interface ListVrackServiceResourceTaskRequest {
+  /** Vrack services ID */
+  vrackServicesId: string;
+  /** Pagination cursor */
+  xPaginationCursor?: string;
+  /** Pagination size */
+  xPaginationSize?: number;
+}
+export const ListVrackServiceResourceTaskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    vrackServicesId: S.String.pipe(T.Label()),
+    xPaginationCursor: S.optional(
+      S.String.pipe(T.Header("X-Pagination-Cursor")),
+    ),
+    xPaginationSize: S.optional(S.Number.pipe(T.Header("X-Pagination-Size"))),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/vrackServices/resource/{vrackServicesId}/task",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListVrackServiceResourceTaskRequest",
+}) as any as S.Schema<ListVrackServiceResourceTaskRequest>;
+
+export type ListVrackServiceResourceTaskResponseBodyList = Array<CommonTask>;
+export const ListVrackServiceResourceTaskResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    CommonTask,
+  ) as any as S.Schema<ListVrackServiceResourceTaskResponseBodyList>;
+
+export type ListVrackServiceResourceTaskResponse =
+  ListVrackServiceResourceTaskResponseBodyList;
+export const ListVrackServiceResourceTaskResponse = /*@__PURE__*/ S.suspend(
+  () => ListVrackServiceResourceTaskResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListVrackServiceResourceTaskResponse",
+}) as any as S.Schema<ListVrackServiceResourceTaskResponse>;
+
+export interface PutVrackServiceResourceRequest {
+  /** Vrack services ID */
+  vrackServicesId: string;
+  /** Computed hash used to control concurrent modification requests. Here, it represents the target specification value the request is based on */
+  checksum: string;
+  /** Requested target specification */
+  targetSpec: VrackServicesVrackServicesTargetSpec;
+}
+export const PutVrackServiceResourceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    vrackServicesId: S.String.pipe(T.Label()),
+    checksum: S.String,
+    targetSpec: VrackServicesVrackServicesTargetSpec,
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/vrackServices/resource/{vrackServicesId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutVrackServiceResourceRequest",
+}) as any as S.Schema<PutVrackServiceResourceRequest>;
+
+/** Asynchronous operations ongoing on the vRack Services */
+export type VrackServicesVrackServicesCurrentTasksList =
+  Array<CommonCurrentTask>;
+export const VrackServicesVrackServicesCurrentTasksList = /*@__PURE__*/ S.Array(
+  CommonCurrentTask,
+) as any as S.Schema<VrackServicesVrackServicesCurrentTasksList>;
+
+/** A vRack Services */
+export interface VrackServicesVrackServices {
+  /** Computed hash used to control concurrent modification requests. Here, it represents the current target specification value */
+  checksum?: string;
+  /** Date of the vRack Services delivery */
+  createdAt?: string;
+  /** Current configuration applied to the vRack Services */
+  currentState?: VrackServicesVrackServicesCurrentState;
+  /** Asynchronous operations ongoing on the vRack Services */
+  currentTasks?: VrackServicesVrackServicesCurrentTasksList | null;
+  /** Unique identifier */
+  id?: string;
+  /** Reflects the readiness of the vRack Services. A new target specification request will be accepted only in `READY` status */
+  resourceStatus?: VrackServicesResourceStatusEnum;
+  /** Last target specification of the vRack Services */
+  targetSpec?: VrackServicesVrackServicesTargetSpec;
+  /** Date of the Last vRack Services update */
+  updatedAt?: string;
+}
+export const VrackServicesVrackServices = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    checksum: S.optional(S.String),
+    createdAt: S.optional(S.String),
+    currentState: S.optional(VrackServicesVrackServicesCurrentState),
+    currentTasks: S.optional(
+      S.NullOr(VrackServicesVrackServicesCurrentTasksList),
+    ),
+    id: S.optional(S.String),
+    resourceStatus: S.optional(VrackServicesResourceStatusEnum),
+    targetSpec: S.optional(VrackServicesVrackServicesTargetSpec),
+    updatedAt: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "VrackServicesVrackServices",
+}) as any as S.Schema<VrackServicesVrackServices>;
+
+export type GetVrackServiceResourceError = NotFound | OvhOpError;
+/** Retrieve a vRack Services */
+export const getVrackServiceResource: API.OperationMethod<
+  GetVrackServiceResourceRequest,
+  VrackServicesVrackServicesWithIAM,
+  GetVrackServiceResourceError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVrackServiceResourceRequest,
+  output: VrackServicesVrackServicesWithIAM,
+  errors: [NotFound, UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVrackServiceResourceTaskError = BadRequest | OvhOpError;
+/** Get the task */
+export const getVrackServiceResourceTask: API.OperationMethod<
+  GetVrackServiceResourceTaskRequest,
+  CommonTask,
+  GetVrackServiceResourceTaskError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVrackServiceResourceTaskRequest,
+  output: CommonTask,
+  errors: [BadRequest, UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackServiceReferenceCompatibleManagedServiceTypeError =
+  OvhOpError;
+/** List all managed service types that are compatible with vRack Services (IAM resource types) The compatible managed service types are represented here by their IAM resource types. */
+export const listVrackServiceReferenceCompatibleManagedServiceType: API.OperationMethod<
+  ListVrackServiceReferenceCompatibleManagedServiceTypeRequest,
+  ListVrackServiceReferenceCompatibleManagedServiceTypeResponse,
+  ListVrackServiceReferenceCompatibleManagedServiceTypeError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackServiceReferenceCompatibleManagedServiceTypeRequest,
+  output: ListVrackServiceReferenceCompatibleManagedServiceTypeResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackServiceReferenceRegionError = OvhOpError;
+/** List all vRack Services regions */
+export const listVrackServiceReferenceRegion: API.OperationMethod<
+  ListVrackServiceReferenceRegionRequest,
+  ListVrackServiceReferenceRegionResponse,
+  ListVrackServiceReferenceRegionError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackServiceReferenceRegionRequest,
+  output: ListVrackServiceReferenceRegionResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackServiceResourceError = OvhOpError;
+/** List all vRack Services */
+export const listVrackServiceResource: API.OperationMethod<
+  ListVrackServiceResourceRequest,
+  ListVrackServiceResourceResponse,
+  ListVrackServiceResourceError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackServiceResourceRequest,
+  output: ListVrackServiceResourceResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackServiceResourceEligibleManagedServiceError = OvhOpError;
+/** List every managed service eligible to the requested vRack Services */
+export const listVrackServiceResourceEligibleManagedService: API.OperationMethod<
+  ListVrackServiceResourceEligibleManagedServiceRequest,
+  ListVrackServiceResourceEligibleManagedServiceResponse,
+  ListVrackServiceResourceEligibleManagedServiceError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackServiceResourceEligibleManagedServiceRequest,
+  output: ListVrackServiceResourceEligibleManagedServiceResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListVrackServiceResourceTaskError = OvhOpError;
+/** List all asynchronous operations related to the vRack Services */
+export const listVrackServiceResourceTask: API.OperationMethod<
+  ListVrackServiceResourceTaskRequest,
+  ListVrackServiceResourceTaskResponse,
+  ListVrackServiceResourceTaskError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListVrackServiceResourceTaskRequest,
+  output: ListVrackServiceResourceTaskResponse,
+  errors: [UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutVrackServiceResourceError = BadRequest | NotFound | OvhOpError;
+/** Request updates on the vRack Services configuration It is the unique route handling any update on the vRack Services configuration. It works as following: 1. You define a new target specification in the request payload, 2. If this specification is validated, you get the resource with updated `targetSpec` and `checksum` values in return, 3. The request is processed by one or several **asynchronous** tasks that aims to reconciliate the `currentState` with the `targetSpec` ### Asynchronous processing * To follow this processing, the VrackServices resource can be polled with `GET /vrackServices/resource/{vrackServicesId}`<br>As soon as its `resourceStatus` is *READY*, the requested specification can be considered as applied to the vRack Services. * The `checksum` helps on detecting concurrency cases on update requests. If the polled `checksum` value differs from the one returned in response of your initial request, it means that processing of your request is completed and another request is being processed. * In case of processing error (i.e. `resourceStatus` in *ERROR*), the current vRack Services configuration is still active, but modification requests will be refused until the intervention of the support. * An overview on the asynchronous task(s) is available via the `currentTasks` attribute.<br>More details on a task are provided by the route `GET /vrackServices/resource/{vrackServicesId}/task/{taskId}` ### Seamless configuration actions The request can combine any of the following seamless actions (meaning there won't be any cut of the service while updating): * create a Subnet * delete a Subnet without any Service Endpoint * update a Subnet: * create one or several Service Endpoints **Note** that a Subnet with several Service Endpoints can be created in the same payload ### Not seamless configuration actions The modification of the Subnet characteristics listed below **WILL** result in a service cut while processing the update as they are interpreted as the deletion of the existing Subnet and creation of a new Subnet with provided characteristics. The IPs that were given to the Managed Services will be reelected and may as a result change: * modifications on the Subnet `ServiceRange` * modifications on the Subnet `Vlan` * modifications on the Subnet `CIDR` The embedded Service Endpoints will be also deleted and re-created which implies a flapping accessibility in the vRack for every related managed services. **Note** that deleting a Subnet will also delete embedded Service Endpoints The `vrackId` is a read-only attribute as the association vRack/vRackServices is handled by the [vRack API](console-preview/?section=%2Fvrack&branch=v1) */
+export const putVrackServiceResource: API.OperationMethod<
+  PutVrackServiceResourceRequest,
+  VrackServicesVrackServices,
+  PutVrackServiceResourceError,
+  OvhOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutVrackServiceResourceRequest,
+  output: VrackServicesVrackServices,
+  errors: [BadRequest, NotFound, UnknownOvhError],
+  protocol: OvhProtocol,
+  retry: Retry.Retry,
+}));