@distilled.cloud/cloudflare 0.0.0 → 0.2.0-alpha

package/src/services/network-interconnects.ts

@@ -0,0 +1,1253 @@
+/**
+ * Cloudflare NETWORK-INTERCONNECTS API
+ *
+ * Generated from Cloudflare TypeScript SDK.
+ * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service network-interconnects
+ */
+
+import * as Schema from "effect/Schema";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import * as API from "../client/api.ts";
+import * as T from "../traits";
+import type { Credentials } from "../credentials";
+import { type DefaultErrors } from "../errors";
+
+// =============================================================================
+// Cni
+// =============================================================================
+
+export interface GetCniRequest {
+  cni: string;
+  /** Customer account tag */
+  accountId: string;
+}
+
+export const GetCniRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  cni: Schema.String.pipe(T.HttpPath("cni")),
+  accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(
+  T.Http({ method: "GET", path: "/accounts/{account_id}/cni/cnis/{cni}" }),
+) as unknown as Schema.Schema<GetCniRequest>;
+
+export interface GetCniResponse {
+  id: string;
+  /** Customer account tag */
+  account: string;
+  /** Customer end of the point-to-point link  This should always be inside the same prefix as `p2p_ip`. */
+  custIp: string;
+  /** Interconnect identifier hosting this CNI */
+  interconnect: string;
+  magic: { conduitName: string; description: string; mtu: number };
+  /** Cloudflare end of the point-to-point link */
+  p2pIp: string;
+  bgp?: {
+    customerAsn: number;
+    extraPrefixes: string[];
+    md5Key?: string | null;
+  } | null;
+}
+
+export const GetCniResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.String,
+  account: Schema.String,
+  custIp: Schema.String,
+  interconnect: Schema.String,
+  magic: Schema.Struct({
+    conduitName: Schema.String,
+    description: Schema.String,
+    mtu: Schema.Number,
+  }).pipe(
+    Schema.encodeKeys({
+      conduitName: "conduit_name",
+      description: "description",
+      mtu: "mtu",
+    }),
+  ),
+  p2pIp: Schema.String,
+  bgp: Schema.optional(
+    Schema.Union([
+      Schema.Struct({
+        customerAsn: Schema.Number,
+        extraPrefixes: Schema.Array(Schema.String),
+        md5Key: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      }).pipe(
+        Schema.encodeKeys({
+          customerAsn: "customer_asn",
+          extraPrefixes: "extra_prefixes",
+          md5Key: "md5_key",
+        }),
+      ),
+      Schema.Null,
+    ]),
+  ),
+}).pipe(
+  Schema.encodeKeys({
+    id: "id",
+    account: "account",
+    custIp: "cust_ip",
+    interconnect: "interconnect",
+    magic: "magic",
+    p2pIp: "p2p_ip",
+    bgp: "bgp",
+  }),
+) as unknown as Schema.Schema<GetCniResponse>;
+
+export type GetCniError = DefaultErrors;
+
+export const getCni: API.OperationMethod<
+  GetCniRequest,
+  GetCniResponse,
+  GetCniError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: GetCniRequest,
+  output: GetCniResponse,
+  errors: [],
+}));
+
+export interface ListCnisRequest {
+  /** Path param: Customer account tag */
+  accountId: string;
+  /** Query param: */
+  cursor?: number | null;
+  /** Query param: */
+  limit?: number | null;
+  /** Query param: If specified, only show CNIs associated with the specified slot */
+  slot?: string | null;
+  /** Query param: If specified, only show cnis associated with the specified tunnel id */
+  tunnelId?: string | null;
+}
+
+export const ListCnisRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  cursor: Schema.optional(Schema.Union([Schema.Number, Schema.Null])).pipe(
+    T.HttpQuery("cursor"),
+  ),
+  limit: Schema.optional(Schema.Union([Schema.Number, Schema.Null])).pipe(
+    T.HttpQuery("limit"),
+  ),
+  slot: Schema.optional(Schema.Union([Schema.String, Schema.Null])).pipe(
+    T.HttpQuery("slot"),
+  ),
+  tunnelId: Schema.optional(Schema.Union([Schema.String, Schema.Null])).pipe(
+    T.HttpQuery("tunnel_id"),
+  ),
+}).pipe(
+  T.Http({ method: "GET", path: "/accounts/{account_id}/cni/cnis" }),
+) as unknown as Schema.Schema<ListCnisRequest>;
+
+export interface ListCnisResponse {
+  items: {
+    id: string;
+    account: string;
+    custIp: string;
+    interconnect: string;
+    magic: { conduitName: string; description: string; mtu: number };
+    p2pIp: string;
+    bgp?: {
+      customerAsn: number;
+      extraPrefixes: string[];
+      md5Key?: string | null;
+    } | null;
+  }[];
+  next?: number | null;
+}
+
+export const ListCnisResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  items: Schema.Array(
+    Schema.Struct({
+      id: Schema.String,
+      account: Schema.String,
+      custIp: Schema.String,
+      interconnect: Schema.String,
+      magic: Schema.Struct({
+        conduitName: Schema.String,
+        description: Schema.String,
+        mtu: Schema.Number,
+      }).pipe(
+        Schema.encodeKeys({
+          conduitName: "conduit_name",
+          description: "description",
+          mtu: "mtu",
+        }),
+      ),
+      p2pIp: Schema.String,
+      bgp: Schema.optional(
+        Schema.Union([
+          Schema.Struct({
+            customerAsn: Schema.Number,
+            extraPrefixes: Schema.Array(Schema.String),
+            md5Key: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+          }).pipe(
+            Schema.encodeKeys({
+              customerAsn: "customer_asn",
+              extraPrefixes: "extra_prefixes",
+              md5Key: "md5_key",
+            }),
+          ),
+          Schema.Null,
+        ]),
+      ),
+    }).pipe(
+      Schema.encodeKeys({
+        id: "id",
+        account: "account",
+        custIp: "cust_ip",
+        interconnect: "interconnect",
+        magic: "magic",
+        p2pIp: "p2p_ip",
+        bgp: "bgp",
+      }),
+    ),
+  ),
+  next: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+}) as unknown as Schema.Schema<ListCnisResponse>;
+
+export type ListCnisError = DefaultErrors;
+
+export const listCnis: API.OperationMethod<
+  ListCnisRequest,
+  ListCnisResponse,
+  ListCnisError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: ListCnisRequest,
+  output: ListCnisResponse,
+  errors: [],
+}));
+
+export interface CreateCniRequest {
+  /** Path param: Customer account tag */
+  accountId: string;
+  /** Body param: Customer account tag */
+  account: string;
+  /** Body param: */
+  interconnect: string;
+  /** Body param: */
+  magic: { conduitName: string; description: string; mtu: number };
+  /** Body param: */
+  bgp?: {
+    customerAsn: number;
+    extraPrefixes: string[];
+    md5Key?: string | null;
+  };
+}
+
+export const CreateCniRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  account: Schema.String,
+  interconnect: Schema.String,
+  magic: Schema.Struct({
+    conduitName: Schema.String,
+    description: Schema.String,
+    mtu: Schema.Number,
+  }).pipe(
+    Schema.encodeKeys({
+      conduitName: "conduit_name",
+      description: "description",
+      mtu: "mtu",
+    }),
+  ),
+  bgp: Schema.optional(
+    Schema.Struct({
+      customerAsn: Schema.Number,
+      extraPrefixes: Schema.Array(Schema.String),
+      md5Key: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(
+      Schema.encodeKeys({
+        customerAsn: "customer_asn",
+        extraPrefixes: "extra_prefixes",
+        md5Key: "md5_key",
+      }),
+    ),
+  ),
+}).pipe(
+  T.Http({ method: "POST", path: "/accounts/{account_id}/cni/cnis" }),
+) as unknown as Schema.Schema<CreateCniRequest>;
+
+export interface CreateCniResponse {
+  id: string;
+  /** Customer account tag */
+  account: string;
+  /** Customer end of the point-to-point link  This should always be inside the same prefix as `p2p_ip`. */
+  custIp: string;
+  /** Interconnect identifier hosting this CNI */
+  interconnect: string;
+  magic: { conduitName: string; description: string; mtu: number };
+  /** Cloudflare end of the point-to-point link */
+  p2pIp: string;
+  bgp?: {
+    customerAsn: number;
+    extraPrefixes: string[];
+    md5Key?: string | null;
+  } | null;
+}
+
+export const CreateCniResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.String,
+  account: Schema.String,
+  custIp: Schema.String,
+  interconnect: Schema.String,
+  magic: Schema.Struct({
+    conduitName: Schema.String,
+    description: Schema.String,
+    mtu: Schema.Number,
+  }).pipe(
+    Schema.encodeKeys({
+      conduitName: "conduit_name",
+      description: "description",
+      mtu: "mtu",
+    }),
+  ),
+  p2pIp: Schema.String,
+  bgp: Schema.optional(
+    Schema.Union([
+      Schema.Struct({
+        customerAsn: Schema.Number,
+        extraPrefixes: Schema.Array(Schema.String),
+        md5Key: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      }).pipe(
+        Schema.encodeKeys({
+          customerAsn: "customer_asn",
+          extraPrefixes: "extra_prefixes",
+          md5Key: "md5_key",
+        }),
+      ),
+      Schema.Null,
+    ]),
+  ),
+}).pipe(
+  Schema.encodeKeys({
+    id: "id",
+    account: "account",
+    custIp: "cust_ip",
+    interconnect: "interconnect",
+    magic: "magic",
+    p2pIp: "p2p_ip",
+    bgp: "bgp",
+  }),
+) as unknown as Schema.Schema<CreateCniResponse>;
+
+export type CreateCniError = DefaultErrors;
+
+export const createCni: API.OperationMethod<
+  CreateCniRequest,
+  CreateCniResponse,
+  CreateCniError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: CreateCniRequest,
+  output: CreateCniResponse,
+  errors: [],
+}));
+
+export interface UpdateCniRequest {
+  cni: string;
+  /** Path param: Customer account tag */
+  accountId: string;
+  /** Body param: */
+  id: string;
+  /** Body param: Customer account tag */
+  account: string;
+  /** Body param: Customer end of the point-to-point link  This should always be inside the same prefix as `p2p_ip`. */
+  custIp: string;
+  /** Body param: Interconnect identifier hosting this CNI */
+  interconnect: string;
+  /** Body param: */
+  magic: { conduitName: string; description: string; mtu: number };
+  /** Body param: Cloudflare end of the point-to-point link */
+  p2pIp: string;
+  /** Body param: */
+  bgp?: {
+    customerAsn: number;
+    extraPrefixes: string[];
+    md5Key?: string | null;
+  };
+}
+
+export const UpdateCniRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  cni: Schema.String.pipe(T.HttpPath("cni")),
+  accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  id: Schema.String,
+  account: Schema.String,
+  custIp: Schema.String,
+  interconnect: Schema.String,
+  magic: Schema.Struct({
+    conduitName: Schema.String,
+    description: Schema.String,
+    mtu: Schema.Number,
+  }).pipe(
+    Schema.encodeKeys({
+      conduitName: "conduit_name",
+      description: "description",
+      mtu: "mtu",
+    }),
+  ),
+  p2pIp: Schema.String,
+  bgp: Schema.optional(
+    Schema.Struct({
+      customerAsn: Schema.Number,
+      extraPrefixes: Schema.Array(Schema.String),
+      md5Key: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(
+      Schema.encodeKeys({
+        customerAsn: "customer_asn",
+        extraPrefixes: "extra_prefixes",
+        md5Key: "md5_key",
+      }),
+    ),
+  ),
+}).pipe(
+  Schema.encodeKeys({
+    id: "id",
+    account: "account",
+    custIp: "cust_ip",
+    interconnect: "interconnect",
+    magic: "magic",
+    p2pIp: "p2p_ip",
+    bgp: "bgp",
+  }),
+  T.Http({ method: "PUT", path: "/accounts/{account_id}/cni/cnis/{cni}" }),
+) as unknown as Schema.Schema<UpdateCniRequest>;
+
+export interface UpdateCniResponse {
+  id: string;
+  /** Customer account tag */
+  account: string;
+  /** Customer end of the point-to-point link  This should always be inside the same prefix as `p2p_ip`. */
+  custIp: string;
+  /** Interconnect identifier hosting this CNI */
+  interconnect: string;
+  magic: { conduitName: string; description: string; mtu: number };
+  /** Cloudflare end of the point-to-point link */
+  p2pIp: string;
+  bgp?: {
+    customerAsn: number;
+    extraPrefixes: string[];
+    md5Key?: string | null;
+  } | null;
+}
+
+export const UpdateCniResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.String,
+  account: Schema.String,
+  custIp: Schema.String,
+  interconnect: Schema.String,
+  magic: Schema.Struct({
+    conduitName: Schema.String,
+    description: Schema.String,
+    mtu: Schema.Number,
+  }).pipe(
+    Schema.encodeKeys({
+      conduitName: "conduit_name",
+      description: "description",
+      mtu: "mtu",
+    }),
+  ),
+  p2pIp: Schema.String,
+  bgp: Schema.optional(
+    Schema.Union([
+      Schema.Struct({
+        customerAsn: Schema.Number,
+        extraPrefixes: Schema.Array(Schema.String),
+        md5Key: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      }).pipe(
+        Schema.encodeKeys({
+          customerAsn: "customer_asn",
+          extraPrefixes: "extra_prefixes",
+          md5Key: "md5_key",
+        }),
+      ),
+      Schema.Null,
+    ]),
+  ),
+}).pipe(
+  Schema.encodeKeys({
+    id: "id",
+    account: "account",
+    custIp: "cust_ip",
+    interconnect: "interconnect",
+    magic: "magic",
+    p2pIp: "p2p_ip",
+    bgp: "bgp",
+  }),
+) as unknown as Schema.Schema<UpdateCniResponse>;
+
+export type UpdateCniError = DefaultErrors;
+
+export const updateCni: API.OperationMethod<
+  UpdateCniRequest,
+  UpdateCniResponse,
+  UpdateCniError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: UpdateCniRequest,
+  output: UpdateCniResponse,
+  errors: [],
+}));
+
+export interface DeleteCniRequest {
+  cni: string;
+  /** Customer account tag */
+  accountId: string;
+}
+
+export const DeleteCniRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  cni: Schema.String.pipe(T.HttpPath("cni")),
+  accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(
+  T.Http({ method: "DELETE", path: "/accounts/{account_id}/cni/cnis/{cni}" }),
+) as unknown as Schema.Schema<DeleteCniRequest>;
+
+export type DeleteCniResponse = unknown;
+
+export const DeleteCniResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown as unknown as Schema.Schema<DeleteCniResponse>;
+
+export type DeleteCniError = DefaultErrors;
+
+export const deleteCni: API.OperationMethod<
+  DeleteCniRequest,
+  DeleteCniResponse,
+  DeleteCniError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: DeleteCniRequest,
+  output: DeleteCniResponse,
+  errors: [],
+}));
+
+// =============================================================================
+// Interconnect
+// =============================================================================
+
+export interface GetInterconnectRequest {
+  icon: string;
+  /** Customer account tag */
+  accountId: string;
+}
+
+export const GetInterconnectRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {
+    icon: Schema.String.pipe(T.HttpPath("icon")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  },
+).pipe(
+  T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/cni/interconnects/{icon}",
+  }),
+) as unknown as Schema.Schema<GetInterconnectRequest>;
+
+export type GetInterconnectResponse =
+  | {
+      account: string;
+      facility: { address: string[]; name: string };
+      name: string;
+      site: string;
+      slotId: string;
+      speed: string;
+      type: string;
+      owner?: string | null;
+    }
+  | {
+      account: string;
+      name: string;
+      region: string;
+      type: string;
+      owner?: string | null;
+      speed?:
+        | "50M"
+        | "100M"
+        | "200M"
+        | "300M"
+        | "400M"
+        | "500M"
+        | "1G"
+        | "2G"
+        | "5G"
+        | "10G"
+        | "20G"
+        | "50G"
+        | null;
+    };
+
+export const GetInterconnectResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Union(
+  [
+    Schema.Struct({
+      account: Schema.String,
+      facility: Schema.Struct({
+        address: Schema.Array(Schema.String),
+        name: Schema.String,
+      }),
+      name: Schema.String,
+      site: Schema.String,
+      slotId: Schema.String,
+      speed: Schema.String,
+      type: Schema.String,
+      owner: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(
+      Schema.encodeKeys({
+        account: "account",
+        facility: "facility",
+        name: "name",
+        site: "site",
+        slotId: "slot_id",
+        speed: "speed",
+        type: "type",
+        owner: "owner",
+      }),
+    ),
+    Schema.Struct({
+      account: Schema.String,
+      name: Schema.String,
+      region: Schema.String,
+      type: Schema.String,
+      owner: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      speed: Schema.optional(
+        Schema.Union([
+          Schema.Literals([
+            "50M",
+            "100M",
+            "200M",
+            "300M",
+            "400M",
+            "500M",
+            "1G",
+            "2G",
+            "5G",
+            "10G",
+            "20G",
+            "50G",
+          ]),
+          Schema.Null,
+        ]),
+      ),
+    }),
+  ],
+) as unknown as Schema.Schema<GetInterconnectResponse>;
+
+export type GetInterconnectError = DefaultErrors;
+
+export const getInterconnect: API.OperationMethod<
+  GetInterconnectRequest,
+  GetInterconnectResponse,
+  GetInterconnectError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: GetInterconnectRequest,
+  output: GetInterconnectResponse,
+  errors: [],
+}));
+
+export interface ListInterconnectsRequest {
+  /** Path param: Customer account tag */
+  accountId: string;
+  /** Query param: */
+  cursor?: number | null;
+  /** Query param: */
+  limit?: number | null;
+  /** Query param: If specified, only show interconnects located at the given site */
+  site?: string | null;
+  /** Query param: If specified, only show interconnects of the given type */
+  type?: string | null;
+}
+
+export const ListInterconnectsRequest =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    cursor: Schema.optional(Schema.Union([Schema.Number, Schema.Null])).pipe(
+      T.HttpQuery("cursor"),
+    ),
+    limit: Schema.optional(Schema.Union([Schema.Number, Schema.Null])).pipe(
+      T.HttpQuery("limit"),
+    ),
+    site: Schema.optional(Schema.Union([Schema.String, Schema.Null])).pipe(
+      T.HttpQuery("site"),
+    ),
+    type: Schema.optional(Schema.Union([Schema.String, Schema.Null])).pipe(
+      T.HttpQuery("type"),
+    ),
+  }).pipe(
+    T.Http({ method: "GET", path: "/accounts/{account_id}/cni/interconnects" }),
+  ) as unknown as Schema.Schema<ListInterconnectsRequest>;
+
+export interface ListInterconnectsResponse {
+  items: (
+    | {
+        account: string;
+        facility: { address: string[]; name: string };
+        name: string;
+        site: string;
+        slotId: string;
+        speed: string;
+        type: string;
+        owner?: string | null;
+      }
+    | {
+        account: string;
+        name: string;
+        region: string;
+        type: string;
+        owner?: string | null;
+        speed?:
+          | "50M"
+          | "100M"
+          | "200M"
+          | "300M"
+          | "400M"
+          | "500M"
+          | "1G"
+          | "2G"
+          | "5G"
+          | "10G"
+          | "20G"
+          | "50G"
+          | null;
+      }
+  )[];
+  next?: number | null;
+}
+
+export const ListInterconnectsResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    items: Schema.Array(
+      Schema.Union([
+        Schema.Struct({
+          account: Schema.String,
+          facility: Schema.Struct({
+            address: Schema.Array(Schema.String),
+            name: Schema.String,
+          }),
+          name: Schema.String,
+          site: Schema.String,
+          slotId: Schema.String,
+          speed: Schema.String,
+          type: Schema.String,
+          owner: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        }).pipe(
+          Schema.encodeKeys({
+            account: "account",
+            facility: "facility",
+            name: "name",
+            site: "site",
+            slotId: "slot_id",
+            speed: "speed",
+            type: "type",
+            owner: "owner",
+          }),
+        ),
+        Schema.Struct({
+          account: Schema.String,
+          name: Schema.String,
+          region: Schema.String,
+          type: Schema.String,
+          owner: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+          speed: Schema.optional(
+            Schema.Union([
+              Schema.Literals([
+                "50M",
+                "100M",
+                "200M",
+                "300M",
+                "400M",
+                "500M",
+                "1G",
+                "2G",
+                "5G",
+                "10G",
+                "20G",
+                "50G",
+              ]),
+              Schema.Null,
+            ]),
+          ),
+        }),
+      ]),
+    ),
+    next: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+  }) as unknown as Schema.Schema<ListInterconnectsResponse>;
+
+export type ListInterconnectsError = DefaultErrors;
+
+export const listInterconnects: API.OperationMethod<
+  ListInterconnectsRequest,
+  ListInterconnectsResponse,
+  ListInterconnectsError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: ListInterconnectsRequest,
+  output: ListInterconnectsResponse,
+  errors: [],
+}));
+
+export interface CreateInterconnectRequest {
+  /** Path param: Customer account tag */
+  accountId: string;
+  /** Body param: */
+  account: string;
+  /** Body param: */
+  slotId: string;
+  /** Body param: */
+  type: string;
+  /** Body param: */
+  speed?: string | null;
+}
+
+export const CreateInterconnectRequest =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    account: Schema.String,
+    slotId: Schema.String,
+    type: Schema.String,
+    speed: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+  }).pipe(
+    Schema.encodeKeys({
+      account: "account",
+      slotId: "slot_id",
+      type: "type",
+      speed: "speed",
+    }),
+    T.Http({
+      method: "POST",
+      path: "/accounts/{account_id}/cni/interconnects",
+    }),
+  ) as unknown as Schema.Schema<CreateInterconnectRequest>;
+
+export type CreateInterconnectResponse =
+  | {
+      account: string;
+      facility: { address: string[]; name: string };
+      name: string;
+      site: string;
+      slotId: string;
+      speed: string;
+      type: string;
+      owner?: string | null;
+    }
+  | {
+      account: string;
+      name: string;
+      region: string;
+      type: string;
+      owner?: string | null;
+      speed?:
+        | "50M"
+        | "100M"
+        | "200M"
+        | "300M"
+        | "400M"
+        | "500M"
+        | "1G"
+        | "2G"
+        | "5G"
+        | "10G"
+        | "20G"
+        | "50G"
+        | null;
+    };
+
+export const CreateInterconnectResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Union([
+    Schema.Struct({
+      account: Schema.String,
+      facility: Schema.Struct({
+        address: Schema.Array(Schema.String),
+        name: Schema.String,
+      }),
+      name: Schema.String,
+      site: Schema.String,
+      slotId: Schema.String,
+      speed: Schema.String,
+      type: Schema.String,
+      owner: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(
+      Schema.encodeKeys({
+        account: "account",
+        facility: "facility",
+        name: "name",
+        site: "site",
+        slotId: "slot_id",
+        speed: "speed",
+        type: "type",
+        owner: "owner",
+      }),
+    ),
+    Schema.Struct({
+      account: Schema.String,
+      name: Schema.String,
+      region: Schema.String,
+      type: Schema.String,
+      owner: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      speed: Schema.optional(
+        Schema.Union([
+          Schema.Literals([
+            "50M",
+            "100M",
+            "200M",
+            "300M",
+            "400M",
+            "500M",
+            "1G",
+            "2G",
+            "5G",
+            "10G",
+            "20G",
+            "50G",
+          ]),
+          Schema.Null,
+        ]),
+      ),
+    }),
+  ]) as unknown as Schema.Schema<CreateInterconnectResponse>;
+
+export type CreateInterconnectError = DefaultErrors;
+
+export const createInterconnect: API.OperationMethod<
+  CreateInterconnectRequest,
+  CreateInterconnectResponse,
+  CreateInterconnectError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: CreateInterconnectRequest,
+  output: CreateInterconnectResponse,
+  errors: [],
+}));
+
+export interface DeleteInterconnectRequest {
+  icon: string;
+  /** Customer account tag */
+  accountId: string;
+}
+
+export const DeleteInterconnectRequest =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    icon: Schema.String.pipe(T.HttpPath("icon")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      path: "/accounts/{account_id}/cni/interconnects/{icon}",
+    }),
+  ) as unknown as Schema.Schema<DeleteInterconnectRequest>;
+
+export type DeleteInterconnectResponse = unknown;
+
+export const DeleteInterconnectResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown as unknown as Schema.Schema<DeleteInterconnectResponse>;
+
+export type DeleteInterconnectError = DefaultErrors;
+
+export const deleteInterconnect: API.OperationMethod<
+  DeleteInterconnectRequest,
+  DeleteInterconnectResponse,
+  DeleteInterconnectError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: DeleteInterconnectRequest,
+  output: DeleteInterconnectResponse,
+  errors: [],
+}));
+
+export interface StatusInterconnectRequest {
+  icon: string;
+  /** Customer account tag */
+  accountId: string;
+}
+
+export const StatusInterconnectRequest =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    icon: Schema.String.pipe(T.HttpPath("icon")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/accounts/{account_id}/cni/interconnects/{icon}/status",
+    }),
+  ) as unknown as Schema.Schema<StatusInterconnectRequest>;
+
+export type StatusInterconnectResponse =
+  | { state: "Pending" }
+  | { state: "Down"; reason?: string | null }
+  | { state: "Unhealthy"; reason?: string | null }
+  | { state: "Healthy" };
+
+export const StatusInterconnectResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Union([
+    Schema.Struct({
+      state: Schema.Literal("Pending"),
+    }),
+    Schema.Struct({
+      state: Schema.Literal("Down"),
+      reason: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }),
+    Schema.Struct({
+      state: Schema.Literal("Unhealthy"),
+      reason: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }),
+    Schema.Struct({
+      state: Schema.Literal("Healthy"),
+    }),
+  ]) as unknown as Schema.Schema<StatusInterconnectResponse>;
+
+export type StatusInterconnectError = DefaultErrors;
+
+export const statusInterconnect: API.OperationMethod<
+  StatusInterconnectRequest,
+  StatusInterconnectResponse,
+  StatusInterconnectError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: StatusInterconnectRequest,
+  output: StatusInterconnectResponse,
+  errors: [],
+}));
+
+export interface LoaInterconnectRequest {
+  icon: string;
+  /** Customer account tag */
+  accountId: string;
+}
+
+export const LoaInterconnectRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {
+    icon: Schema.String.pipe(T.HttpPath("icon")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  },
+).pipe(
+  T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/cni/interconnects/{icon}/loa",
+  }),
+) as unknown as Schema.Schema<LoaInterconnectRequest>;
+
+export type LoaInterconnectResponse = unknown;
+
+export const LoaInterconnectResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown as unknown as Schema.Schema<LoaInterconnectResponse>;
+
+export type LoaInterconnectError = DefaultErrors;
+
+export const loaInterconnect: API.OperationMethod<
+  LoaInterconnectRequest,
+  LoaInterconnectResponse,
+  LoaInterconnectError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: LoaInterconnectRequest,
+  output: LoaInterconnectResponse,
+  errors: [],
+}));
+
+// =============================================================================
+// Setting
+// =============================================================================
+
+export interface GetSettingRequest {
+  /** Account tag to retrieve settings for */
+  accountId: string;
+}
+
+export const GetSettingRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(
+  T.Http({ method: "GET", path: "/accounts/{account_id}/cni/settings" }),
+) as unknown as Schema.Schema<GetSettingRequest>;
+
+export interface GetSettingResponse {
+  defaultAsn: number;
+}
+
+export const GetSettingResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  defaultAsn: Schema.Number,
+}).pipe(
+  Schema.encodeKeys({ defaultAsn: "default_asn" }),
+) as unknown as Schema.Schema<GetSettingResponse>;
+
+export type GetSettingError = DefaultErrors;
+
+export const getSetting: API.OperationMethod<
+  GetSettingRequest,
+  GetSettingResponse,
+  GetSettingError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: GetSettingRequest,
+  output: GetSettingResponse,
+  errors: [],
+}));
+
+export interface PutSettingRequest {
+  /** Path param: Account tag to update settings for */
+  accountId: string;
+  /** Body param: */
+  defaultAsn?: number | null;
+}
+
+export const PutSettingRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  defaultAsn: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+}).pipe(
+  Schema.encodeKeys({ defaultAsn: "default_asn" }),
+  T.Http({ method: "PUT", path: "/accounts/{account_id}/cni/settings" }),
+) as unknown as Schema.Schema<PutSettingRequest>;
+
+export interface PutSettingResponse {
+  defaultAsn: number;
+}
+
+export const PutSettingResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  defaultAsn: Schema.Number,
+}).pipe(
+  Schema.encodeKeys({ defaultAsn: "default_asn" }),
+) as unknown as Schema.Schema<PutSettingResponse>;
+
+export type PutSettingError = DefaultErrors;
+
+export const putSetting: API.OperationMethod<
+  PutSettingRequest,
+  PutSettingResponse,
+  PutSettingError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: PutSettingRequest,
+  output: PutSettingResponse,
+  errors: [],
+}));
+
+// =============================================================================
+// Slot
+// =============================================================================
+
+export interface GetSlotRequest {
+  slot: string;
+  /** Customer account tag */
+  accountId: string;
+}
+
+export const GetSlotRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  slot: Schema.String.pipe(T.HttpPath("slot")),
+  accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(
+  T.Http({ method: "GET", path: "/accounts/{account_id}/cni/slots/{slot}" }),
+) as unknown as Schema.Schema<GetSlotRequest>;
+
+export interface GetSlotResponse {
+  /** Slot ID */
+  id: string;
+  facility: { address: string[]; name: string };
+  /** Whether the slot is occupied or not */
+  occupied: boolean;
+  site: string;
+  speed: string;
+  /** Customer account tag */
+  account?: string | null;
+}
+
+export const GetSlotResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.String,
+  facility: Schema.Struct({
+    address: Schema.Array(Schema.String),
+    name: Schema.String,
+  }),
+  occupied: Schema.Boolean,
+  site: Schema.String,
+  speed: Schema.String,
+  account: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+}) as unknown as Schema.Schema<GetSlotResponse>;
+
+export type GetSlotError = DefaultErrors;
+
+export const getSlot: API.OperationMethod<
+  GetSlotRequest,
+  GetSlotResponse,
+  GetSlotError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: GetSlotRequest,
+  output: GetSlotResponse,
+  errors: [],
+}));
+
+export interface ListSlotsRequest {
+  /** Path param: Customer account tag */
+  accountId: string;
+  /** Query param: If specified, only show slots with the given text in their address field */
+  addressContains?: string | null;
+  /** Query param: */
+  cursor?: number | null;
+  /** Query param: */
+  limit?: number | null;
+  /** Query param: If specified, only show slots with a specific occupied/unoccupied state */
+  occupied?: boolean | null;
+  /** Query param: If specified, only show slots located at the given site */
+  site?: string | null;
+  /** Query param: If specified, only show slots that support the given speed */
+  speed?: string | null;
+}
+
+export const ListSlotsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  addressContains: Schema.optional(
+    Schema.Union([Schema.String, Schema.Null]),
+  ).pipe(T.HttpQuery("address_contains")),
+  cursor: Schema.optional(Schema.Union([Schema.Number, Schema.Null])).pipe(
+    T.HttpQuery("cursor"),
+  ),
+  limit: Schema.optional(Schema.Union([Schema.Number, Schema.Null])).pipe(
+    T.HttpQuery("limit"),
+  ),
+  occupied: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])).pipe(
+    T.HttpQuery("occupied"),
+  ),
+  site: Schema.optional(Schema.Union([Schema.String, Schema.Null])).pipe(
+    T.HttpQuery("site"),
+  ),
+  speed: Schema.optional(Schema.Union([Schema.String, Schema.Null])).pipe(
+    T.HttpQuery("speed"),
+  ),
+}).pipe(
+  T.Http({ method: "GET", path: "/accounts/{account_id}/cni/slots" }),
+) as unknown as Schema.Schema<ListSlotsRequest>;
+
+export interface ListSlotsResponse {
+  items: {
+    id: string;
+    facility: { address: string[]; name: string };
+    occupied: boolean;
+    site: string;
+    speed: string;
+    account?: string | null;
+  }[];
+  next?: number | null;
+}
+
+export const ListSlotsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  items: Schema.Array(
+    Schema.Struct({
+      id: Schema.String,
+      facility: Schema.Struct({
+        address: Schema.Array(Schema.String),
+        name: Schema.String,
+      }),
+      occupied: Schema.Boolean,
+      site: Schema.String,
+      speed: Schema.String,
+      account: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }),
+  ),
+  next: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+}) as unknown as Schema.Schema<ListSlotsResponse>;
+
+export type ListSlotsError = DefaultErrors;
+
+export const listSlots: API.OperationMethod<
+  ListSlotsRequest,
+  ListSlotsResponse,
+  ListSlotsError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: ListSlotsRequest,
+  output: ListSlotsResponse,
+  errors: [],
+}));