// AUTO-GENERATED by scripts/generate.ts from .generated-specs. 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 {
  CloudflareProtocol,
  type CloudflareOpError,
  type CloudflareOpContext,
} from "../protocol.ts";
import { CloudflareError, CloudflareRateLimited } from "../errors.ts";
import * as Retry from "../retry.ts";

export type { CloudflareOpError, CloudflareOpContext };

/** Fallback camelCase→wire mapping for opaque content (mined from the distilled SDK). */
const KEY_DICTIONARY: Record<string, string | ReadonlyArray<string>> = {
  conduitName: "conduit_name",
  custIp: "cust_ip",
  customerAsn: "customer_asn",
  defaultAsn: "default_asn",
  extraPrefixes: "extra_prefixes",
  md5Key: "md5_key",
  p2pIp: "p2p_ip",
  pairingKey: "pairing_key",
  slotId: "slot_id",
};

export class Forbidden
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<Forbidden>()("Forbidden", {
      code: S.Number,
      message: S.String,
    }),
    [{ status: 403 }],
  ) {}

export interface CnisCreateRequestMagic {
  conduitName: string;
  description: string;
  mtu: number;
}
export const CnisCreateRequestMagic = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    conduitName: S.String.pipe(T.Body("conduit_name")),
    description: S.String,
    mtu: S.Number,
  }),
).annotate({
  identifier: "CnisCreateRequestMagic",
}) as any as S.Schema<CnisCreateRequestMagic>;

export type CnisCreateRequestBgpExtraPrefixesList = Array<string>;
export const CnisCreateRequestBgpExtraPrefixesList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<CnisCreateRequestBgpExtraPrefixesList>;

export interface CnisCreateRequestBgp {
  /** ASN used on the customer end of the BGP session */
  customerAsn: number;
  /** Extra set of static prefixes to advertise to the customer's end of the session */
  extraPrefixes: CnisCreateRequestBgpExtraPrefixesList;
  /** MD5 key to use for session authentication. */
  md5Key?: string;
}
export const CnisCreateRequestBgp = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    customerAsn: S.Number.pipe(T.Body("customer_asn")),
    extraPrefixes: CnisCreateRequestBgpExtraPrefixesList.pipe(
      T.Body("extra_prefixes"),
    ),
    md5Key: S.optional(S.String.pipe(T.Body("md5_key"))),
  }),
).annotate({
  identifier: "CnisCreateRequestBgp",
}) as any as S.Schema<CnisCreateRequestBgp>;

export interface CreateCniRequest {
  /** Customer account tag */
  accountId: string;
  /** Customer account tag */
  account: string;
  interconnect: string;
  magic: CnisCreateRequestMagic;
  bgp?: CnisCreateRequestBgp;
}
export const CreateCniRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    account: S.String,
    interconnect: S.String,
    magic: CnisCreateRequestMagic,
    bgp: S.optional(CnisCreateRequestBgp),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/cni/cnis",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateCniRequest",
}) as any as S.Schema<CreateCniRequest>;

export type CnisCreateResponseMagic = CnisCreateRequestMagic;
export const CnisCreateResponseMagic = CnisCreateRequestMagic;

export type CnisCreateResponseBgpExtraPrefixesList = Array<string>;
export const CnisCreateResponseBgpExtraPrefixesList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<CnisCreateResponseBgpExtraPrefixesList>;

export interface CnisCreateResponseBgp {
  /** ASN used on the customer end of the BGP session */
  customerAsn: number;
  /** Extra set of static prefixes to advertise to the customer's end of the session */
  extraPrefixes: CnisCreateResponseBgpExtraPrefixesList;
  /** MD5 key to use for session authentication. */
  md5Key?: string | null;
}
export const CnisCreateResponseBgp = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    customerAsn: S.Number.pipe(T.Body("customer_asn")),
    extraPrefixes: CnisCreateResponseBgpExtraPrefixesList.pipe(
      T.Body("extra_prefixes"),
    ),
    md5Key: S.optional(S.NullOr(S.String).pipe(T.Body("md5_key"))),
  }),
).annotate({
  identifier: "CnisCreateResponseBgp",
}) as any as S.Schema<CnisCreateResponseBgp>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface CreateCniResponse {
  id: string;
  /** Customer account tag */
  account: string;
  /** Customer end of the point-to-point link */
  custIp: string;
  /** Interconnect identifier hosting this CNI */
  interconnect: string;
  magic: CnisCreateRequestMagic;
  /** Cloudflare end of the point-to-point link */
  p2pIp: string;
  bgp?: CnisCreateResponseBgp | null;
}
export const CreateCniResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    account: S.String,
    custIp: S.String.pipe(T.Body("cust_ip")),
    interconnect: S.String,
    magic: CnisCreateRequestMagic,
    p2pIp: S.String.pipe(T.Body("p2p_ip")),
    bgp: S.optional(S.NullOr(CnisCreateResponseBgp)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateCniResponse",
}) as any as S.Schema<CreateCniResponse>;

export type InterconnectsCreateRequestBandwidth =
  | "50M"
  | "100M"
  | "200M"
  | "300M"
  | "400M"
  | "500M"
  | "1G"
  | "2G"
  | "5G"
  | "10G"
  | "20G"
  | "50G";
export const InterconnectsCreateRequestBandwidth = /*@__PURE__*/ S.String;

export interface CreateInterconnectRequest {
  /** Customer account tag */
  accountId: string;
  account: string;
  slotId?: string;
  type: string;
  speed?: string;
  /** Bandwidth structure as visible through the customer-facing API. */
  bandwidth?: InterconnectsCreateRequestBandwidth | (string & {});
  /** Pairing key provided by GCP */
  pairingKey?: string;
}
export const CreateInterconnectRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    account: S.String,
    slotId: S.optional(S.String.pipe(T.Body("slot_id"))),
    type: S.String,
    speed: S.optional(S.String),
    bandwidth: S.optional(InterconnectsCreateRequestBandwidth),
    pairingKey: S.optional(S.String.pipe(T.Body("pairing_key"))),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/cni/interconnects",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateInterconnectRequest",
}) as any as S.Schema<CreateInterconnectRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface CreateInterconnectResponse {}
export const CreateInterconnectResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({}).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateInterconnectResponse",
}) as any as S.Schema<CreateInterconnectResponse>;

export interface DeleteCniRequest {
  /** Customer account tag */
  accountId: string;
  cni: string;
}
export const DeleteCniRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    cni: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/cni/cnis/{cni}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteCniRequest",
}) as any as S.Schema<DeleteCniRequest>;

export interface DeleteCniResponse {}
export const DeleteCniResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({}).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteCniResponse",
}) as any as S.Schema<DeleteCniResponse>;

export interface DeleteInterconnectRequest {
  /** Customer account tag */
  accountId: string;
  icon: string;
}
export const DeleteInterconnectRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    icon: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/cni/interconnects/{icon}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteInterconnectRequest",
}) as any as S.Schema<DeleteInterconnectRequest>;

export interface DeleteInterconnectResponse {}
export const DeleteInterconnectResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({}).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteInterconnectResponse",
}) as any as S.Schema<DeleteInterconnectResponse>;

export interface GetCniRequest {
  /** Customer account tag */
  accountId: string;
  cni: string;
}
export const GetCniRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    cni: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cni/cnis/{cni}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({ identifier: "GetCniRequest" }) as any as S.Schema<GetCniRequest>;

export type CnisGetResponseMagic = CnisCreateRequestMagic;
export const CnisGetResponseMagic = CnisCreateRequestMagic;

export type CnisGetResponseBgpExtraPrefixesList = Array<string>;
export const CnisGetResponseBgpExtraPrefixesList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<CnisGetResponseBgpExtraPrefixesList>;

export interface CnisGetResponseBgp {
  /** ASN used on the customer end of the BGP session */
  customerAsn: number;
  /** Extra set of static prefixes to advertise to the customer's end of the session */
  extraPrefixes: CnisGetResponseBgpExtraPrefixesList;
  /** MD5 key to use for session authentication. */
  md5Key?: string | null;
}
export const CnisGetResponseBgp = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    customerAsn: S.Number.pipe(T.Body("customer_asn")),
    extraPrefixes: CnisGetResponseBgpExtraPrefixesList.pipe(
      T.Body("extra_prefixes"),
    ),
    md5Key: S.optional(S.NullOr(S.String).pipe(T.Body("md5_key"))),
  }),
).annotate({
  identifier: "CnisGetResponseBgp",
}) as any as S.Schema<CnisGetResponseBgp>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetCniResponse {
  id: string;
  /** Customer account tag */
  account: string;
  /** Customer end of the point-to-point link */
  custIp: string;
  /** Interconnect identifier hosting this CNI */
  interconnect: string;
  magic: CnisCreateRequestMagic;
  /** Cloudflare end of the point-to-point link */
  p2pIp: string;
  bgp?: CnisGetResponseBgp | null;
}
export const GetCniResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    account: S.String,
    custIp: S.String.pipe(T.Body("cust_ip")),
    interconnect: S.String,
    magic: CnisCreateRequestMagic,
    p2pIp: S.String.pipe(T.Body("p2p_ip")),
    bgp: S.optional(S.NullOr(CnisGetResponseBgp)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({ identifier: "GetCniResponse" }) as any as S.Schema<GetCniResponse>;

export interface GetInterconnectRequest {
  /** Customer account tag */
  accountId: string;
  icon: string;
}
export const GetInterconnectRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    icon: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cni/interconnects/{icon}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetInterconnectRequest",
}) as any as S.Schema<GetInterconnectRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetInterconnectResponse {}
export const GetInterconnectResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({}).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetInterconnectResponse",
}) as any as S.Schema<GetInterconnectResponse>;

export interface GetSettingRequest {
  accountId: string;
}
export const GetSettingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cni/settings",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSettingRequest",
}) as any as S.Schema<GetSettingRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetSettingResponse {
  defaultAsn: number;
}
export const GetSettingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    defaultAsn: S.Number.pipe(T.Body("default_asn")),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSettingResponse",
}) as any as S.Schema<GetSettingResponse>;

export interface GetSlotRequest {
  /** Customer account tag */
  accountId: string;
  slot: string;
}
export const GetSlotRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    slot: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cni/slots/{slot}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({ identifier: "GetSlotRequest" }) as any as S.Schema<GetSlotRequest>;

export type SlotsGetResponseFacilityAddressList = Array<string>;
export const SlotsGetResponseFacilityAddressList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<SlotsGetResponseFacilityAddressList>;

export interface SlotsGetResponseFacility {
  address: SlotsGetResponseFacilityAddressList;
  name: string;
}
export const SlotsGetResponseFacility = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    address: SlotsGetResponseFacilityAddressList,
    name: S.String,
  }),
).annotate({
  identifier: "SlotsGetResponseFacility",
}) as any as S.Schema<SlotsGetResponseFacility>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetSlotResponse {
  /** Slot ID */
  id: string;
  facility: SlotsGetResponseFacility;
  /** Whether the slot is occupied or not */
  occupied: boolean;
  site: string;
  speed: string;
  /** Customer account tag */
  account?: string | null;
}
export const GetSlotResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    facility: SlotsGetResponseFacility,
    occupied: S.Boolean,
    site: S.String,
    speed: S.String,
    account: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSlotResponse",
}) as any as S.Schema<GetSlotResponse>;

export interface ListCnisRequest {
  /** Customer account tag */
  accountId: string;
  cursor?: number;
  limit?: number;
  /** If specified, only show CNIs associated with the specified slot */
  slot?: string;
  /** If specified, only show cnis associated with the specified tunnel id */
  tunnelId?: string;
}
export const ListCnisRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    cursor: S.optional(S.Number.pipe(T.Query())),
    limit: S.optional(S.Number.pipe(T.Query())),
    slot: S.optional(S.String.pipe(T.Query())),
    tunnelId: S.optional(S.String.pipe(T.Query("tunnel_id"))),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cni/cnis",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListCnisRequest",
}) as any as S.Schema<ListCnisRequest>;

export type CnisListResponseItemsItemMagic = CnisCreateRequestMagic;
export const CnisListResponseItemsItemMagic = CnisCreateRequestMagic;

export type CnisListResponseItemsItemBgpExtraPrefixesList = Array<string>;
export const CnisListResponseItemsItemBgpExtraPrefixesList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<CnisListResponseItemsItemBgpExtraPrefixesList>;

export interface CnisListResponseItemsItemBgp {
  /** ASN used on the customer end of the BGP session */
  customerAsn: number;
  /** Extra set of static prefixes to advertise to the customer's end of the session */
  extraPrefixes: CnisListResponseItemsItemBgpExtraPrefixesList;
  /** MD5 key to use for session authentication. */
  md5Key?: string | null;
}
export const CnisListResponseItemsItemBgp = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    customerAsn: S.Number.pipe(T.Body("customer_asn")),
    extraPrefixes: CnisListResponseItemsItemBgpExtraPrefixesList.pipe(
      T.Body("extra_prefixes"),
    ),
    md5Key: S.optional(S.NullOr(S.String).pipe(T.Body("md5_key"))),
  }),
).annotate({
  identifier: "CnisListResponseItemsItemBgp",
}) as any as S.Schema<CnisListResponseItemsItemBgp>;

export interface CnisListResponseItemsItem {
  id: string;
  /** Customer account tag */
  account: string;
  /** Customer end of the point-to-point link */
  custIp: string;
  /** Interconnect identifier hosting this CNI */
  interconnect: string;
  magic: CnisCreateRequestMagic;
  /** Cloudflare end of the point-to-point link */
  p2pIp: string;
  bgp?: CnisListResponseItemsItemBgp | null;
}
export const CnisListResponseItemsItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    account: S.String,
    custIp: S.String.pipe(T.Body("cust_ip")),
    interconnect: S.String,
    magic: CnisCreateRequestMagic,
    p2pIp: S.String.pipe(T.Body("p2p_ip")),
    bgp: S.optional(S.NullOr(CnisListResponseItemsItemBgp)),
  }),
).annotate({
  identifier: "CnisListResponseItemsItem",
}) as any as S.Schema<CnisListResponseItemsItem>;

export type CnisListResponseItemsList = Array<CnisListResponseItemsItem>;
export const CnisListResponseItemsList = /*@__PURE__*/ S.Array(
  CnisListResponseItemsItem,
) as any as S.Schema<CnisListResponseItemsList>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface ListCnisResponse {
  items: CnisListResponseItemsList;
  next?: number | null;
}
export const ListCnisResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    items: CnisListResponseItemsList,
    next: S.optional(S.NullOr(S.Number)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListCnisResponse",
}) as any as S.Schema<ListCnisResponse>;

export interface ListInterconnectsRequest {
  /** Customer account tag */
  accountId: string;
  cursor?: number;
  limit?: number;
  /** If specified, only show interconnects located at the given site */
  site?: string;
  /** If specified, only show interconnects of the given type */
  type?: string;
}
export const ListInterconnectsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    cursor: S.optional(S.Number.pipe(T.Query())),
    limit: S.optional(S.Number.pipe(T.Query())),
    site: S.optional(S.String.pipe(T.Query())),
    type: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cni/interconnects",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListInterconnectsRequest",
}) as any as S.Schema<ListInterconnectsRequest>;

export type InterconnectsListResponseItemsItemNscInterconnectPhysicalBodyFacilityAddressList =
  Array<string>;
export const InterconnectsListResponseItemsItemNscInterconnectPhysicalBodyFacilityAddressList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<InterconnectsListResponseItemsItemNscInterconnectPhysicalBodyFacilityAddressList>;

export interface InterconnectsListResponseItemsItemNscInterconnectPhysicalBodyFacility {
  address: InterconnectsListResponseItemsItemNscInterconnectPhysicalBodyFacilityAddressList;
  name: string;
}
export const InterconnectsListResponseItemsItemNscInterconnectPhysicalBodyFacility =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      address:
        InterconnectsListResponseItemsItemNscInterconnectPhysicalBodyFacilityAddressList,
      name: S.String,
    }),
  ).annotate({
    identifier:
      "InterconnectsListResponseItemsItemNscInterconnectPhysicalBodyFacility",
  }) as any as S.Schema<InterconnectsListResponseItemsItemNscInterconnectPhysicalBodyFacility>;

export interface InterconnectsListResponseItemsItemNscInterconnectPhysicalBody {
  account: string;
  facility: InterconnectsListResponseItemsItemNscInterconnectPhysicalBodyFacility;
  name: string;
  /** A Cloudflare site name. */
  site: string;
  slotId: string;
  speed: string;
  type: string;
  owner?: string | null;
}
export const InterconnectsListResponseItemsItemNscInterconnectPhysicalBody =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      account: S.String,
      facility:
        InterconnectsListResponseItemsItemNscInterconnectPhysicalBodyFacility,
      name: S.String,
      site: S.String,
      slotId: S.String.pipe(T.Body("slot_id")),
      speed: S.String,
      type: S.String,
      owner: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "InterconnectsListResponseItemsItemNscInterconnectPhysicalBody",
  }) as any as S.Schema<InterconnectsListResponseItemsItemNscInterconnectPhysicalBody>;

export type InterconnectsListResponseItemsItemNscInterconnectGcpPartnerBodySpeed =
  | "50M"
  | "100M"
  | "200M"
  | "300M"
  | "400M"
  | "500M"
  | "1G"
  | "2G"
  | "5G"
  | "10G"
  | "20G"
  | "50G";
export const InterconnectsListResponseItemsItemNscInterconnectGcpPartnerBodySpeed =
  /*@__PURE__*/ S.String;

export interface InterconnectsListResponseItemsItemNscInterconnectGcpPartnerBody {
  account: string;
  name: string;
  region: string;
  type: string;
  owner?: string | null;
  /** Bandwidth structure as visible through the customer-facing API. */
  speed?: InterconnectsListResponseItemsItemNscInterconnectGcpPartnerBodySpeed | null;
}
export const InterconnectsListResponseItemsItemNscInterconnectGcpPartnerBody =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      account: S.String,
      name: S.String,
      region: S.String,
      type: S.String,
      owner: S.optional(S.NullOr(S.String)),
      speed: S.optional(
        S.NullOr(
          InterconnectsListResponseItemsItemNscInterconnectGcpPartnerBodySpeed,
        ),
      ),
    }),
  ).annotate({
    identifier:
      "InterconnectsListResponseItemsItemNscInterconnectGcpPartnerBody",
  }) as any as S.Schema<InterconnectsListResponseItemsItemNscInterconnectGcpPartnerBody>;

export type InterconnectsListResponseItemsItem =
  | InterconnectsListResponseItemsItemNscInterconnectPhysicalBody
  | InterconnectsListResponseItemsItemNscInterconnectGcpPartnerBody;
export const InterconnectsListResponseItemsItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["account", "facility", "name", "site", "slotId", "speed", "type", "owner"],
    ["account", "name", "region", "type", "owner", "speed"],
  ]),
);

export type InterconnectsListResponseItemsList =
  Array<InterconnectsListResponseItemsItem>;
export const InterconnectsListResponseItemsList = /*@__PURE__*/ S.Array(
  InterconnectsListResponseItemsItem,
) as any as S.Schema<InterconnectsListResponseItemsList>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface ListInterconnectsResponse {
  items: InterconnectsListResponseItemsList;
  next?: number | null;
}
export const ListInterconnectsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    items: InterconnectsListResponseItemsList,
    next: S.optional(S.NullOr(S.Number)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListInterconnectsResponse",
}) as any as S.Schema<ListInterconnectsResponse>;

export interface ListSlotsRequest {
  /** Customer account tag */
  accountId: string;
  /** If specified, only show slots with the given text in their address field */
  addressContains?: string;
  cursor?: number;
  limit?: number;
  /** If specified, only show slots with a specific occupied/unoccupied state */
  occupied?: boolean;
  /** If specified, only show slots located at the given site */
  site?: string;
  /** If specified, only show slots that support the given speed */
  speed?: string;
}
export const ListSlotsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    addressContains: S.optional(S.String.pipe(T.Query("address_contains"))),
    cursor: S.optional(S.Number.pipe(T.Query())),
    limit: S.optional(S.Number.pipe(T.Query())),
    occupied: S.optional(S.Boolean.pipe(T.Query())),
    site: S.optional(S.String.pipe(T.Query())),
    speed: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cni/slots",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListSlotsRequest",
}) as any as S.Schema<ListSlotsRequest>;

export type SlotsListResponseItemsItemFacilityAddressList = Array<string>;
export const SlotsListResponseItemsItemFacilityAddressList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<SlotsListResponseItemsItemFacilityAddressList>;

export interface SlotsListResponseItemsItemFacility {
  address: SlotsListResponseItemsItemFacilityAddressList;
  name: string;
}
export const SlotsListResponseItemsItemFacility = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    address: SlotsListResponseItemsItemFacilityAddressList,
    name: S.String,
  }),
).annotate({
  identifier: "SlotsListResponseItemsItemFacility",
}) as any as S.Schema<SlotsListResponseItemsItemFacility>;

export interface SlotsListResponseItemsItem {
  /** Slot ID */
  id: string;
  facility: SlotsListResponseItemsItemFacility;
  /** Whether the slot is occupied or not */
  occupied: boolean;
  site: string;
  speed: string;
  /** Customer account tag */
  account?: string | null;
}
export const SlotsListResponseItemsItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    facility: SlotsListResponseItemsItemFacility,
    occupied: S.Boolean,
    site: S.String,
    speed: S.String,
    account: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "SlotsListResponseItemsItem",
}) as any as S.Schema<SlotsListResponseItemsItem>;

export type SlotsListResponseItemsList = Array<SlotsListResponseItemsItem>;
export const SlotsListResponseItemsList = /*@__PURE__*/ S.Array(
  SlotsListResponseItemsItem,
) as any as S.Schema<SlotsListResponseItemsList>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface ListSlotsResponse {
  items: SlotsListResponseItemsList;
  next?: number | null;
}
export const ListSlotsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    items: SlotsListResponseItemsList,
    next: S.optional(S.NullOr(S.Number)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListSlotsResponse",
}) as any as S.Schema<ListSlotsResponse>;

export interface LoaInterconnectRequest {
  /** Customer account tag */
  accountId: string;
  icon: string;
}
export const LoaInterconnectRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    icon: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cni/interconnects/{icon}/loa",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "LoaInterconnectRequest",
}) as any as S.Schema<LoaInterconnectRequest>;

export interface LoaInterconnectResponse {}
export const LoaInterconnectResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({}).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "LoaInterconnectResponse",
}) as any as S.Schema<LoaInterconnectResponse>;

export interface PutSettingRequest {
  accountId: string;
  defaultAsn?: number;
}
export const PutSettingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    defaultAsn: S.optional(S.Number.pipe(T.Body("default_asn"))),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/accounts/{account_id}/cni/settings",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PutSettingRequest",
}) as any as S.Schema<PutSettingRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface PutSettingResponse {
  defaultAsn: number;
}
export const PutSettingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    defaultAsn: S.Number.pipe(T.Body("default_asn")),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PutSettingResponse",
}) as any as S.Schema<PutSettingResponse>;

export interface StatusInterconnectRequest {
  /** Customer account tag */
  accountId: string;
  icon: string;
}
export const StatusInterconnectRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    icon: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cni/interconnects/{icon}/status",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "StatusInterconnectRequest",
}) as any as S.Schema<StatusInterconnectRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface StatusInterconnectResponse {}
export const StatusInterconnectResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({}).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "StatusInterconnectResponse",
}) as any as S.Schema<StatusInterconnectResponse>;

export type CnisUpdateRequestMagic = CnisCreateRequestMagic;
export const CnisUpdateRequestMagic = CnisCreateRequestMagic;

export type CnisUpdateRequestBgpExtraPrefixesList = Array<string>;
export const CnisUpdateRequestBgpExtraPrefixesList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<CnisUpdateRequestBgpExtraPrefixesList>;

export interface CnisUpdateRequestBgp {
  /** ASN used on the customer end of the BGP session */
  customerAsn: number;
  /** Extra set of static prefixes to advertise to the customer's end of the session */
  extraPrefixes: CnisUpdateRequestBgpExtraPrefixesList;
  /** MD5 key to use for session authentication. */
  md5Key?: string;
}
export const CnisUpdateRequestBgp = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    customerAsn: S.Number.pipe(T.Body("customer_asn")),
    extraPrefixes: CnisUpdateRequestBgpExtraPrefixesList.pipe(
      T.Body("extra_prefixes"),
    ),
    md5Key: S.optional(S.String.pipe(T.Body("md5_key"))),
  }),
).annotate({
  identifier: "CnisUpdateRequestBgp",
}) as any as S.Schema<CnisUpdateRequestBgp>;

export interface UpdateCniRequest {
  /** Customer account tag */
  accountId: string;
  cni: string;
  id: string;
  /** Customer account tag */
  account: string;
  /** Customer end of the point-to-point link */
  custIp: string;
  /** Interconnect identifier hosting this CNI */
  interconnect: string;
  magic: CnisCreateRequestMagic;
  /** Cloudflare end of the point-to-point link */
  p2pIp: string;
  bgp?: CnisUpdateRequestBgp;
}
export const UpdateCniRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    cni: S.String.pipe(T.Label()),
    id: S.String,
    account: S.String,
    custIp: S.String.pipe(T.Body("cust_ip")),
    interconnect: S.String,
    magic: CnisCreateRequestMagic,
    p2pIp: S.String.pipe(T.Body("p2p_ip")),
    bgp: S.optional(CnisUpdateRequestBgp),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/accounts/{account_id}/cni/cnis/{cni}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateCniRequest",
}) as any as S.Schema<UpdateCniRequest>;

export type CnisUpdateResponseMagic = CnisCreateRequestMagic;
export const CnisUpdateResponseMagic = CnisCreateRequestMagic;

export type CnisUpdateResponseBgpExtraPrefixesList = Array<string>;
export const CnisUpdateResponseBgpExtraPrefixesList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<CnisUpdateResponseBgpExtraPrefixesList>;

export interface CnisUpdateResponseBgp {
  /** ASN used on the customer end of the BGP session */
  customerAsn: number;
  /** Extra set of static prefixes to advertise to the customer's end of the session */
  extraPrefixes: CnisUpdateResponseBgpExtraPrefixesList;
  /** MD5 key to use for session authentication. */
  md5Key?: string | null;
}
export const CnisUpdateResponseBgp = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    customerAsn: S.Number.pipe(T.Body("customer_asn")),
    extraPrefixes: CnisUpdateResponseBgpExtraPrefixesList.pipe(
      T.Body("extra_prefixes"),
    ),
    md5Key: S.optional(S.NullOr(S.String).pipe(T.Body("md5_key"))),
  }),
).annotate({
  identifier: "CnisUpdateResponseBgp",
}) as any as S.Schema<CnisUpdateResponseBgp>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface UpdateCniResponse {
  id: string;
  /** Customer account tag */
  account: string;
  /** Customer end of the point-to-point link */
  custIp: string;
  /** Interconnect identifier hosting this CNI */
  interconnect: string;
  magic: CnisCreateRequestMagic;
  /** Cloudflare end of the point-to-point link */
  p2pIp: string;
  bgp?: CnisUpdateResponseBgp | null;
}
export const UpdateCniResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    account: S.String,
    custIp: S.String.pipe(T.Body("cust_ip")),
    interconnect: S.String,
    magic: CnisCreateRequestMagic,
    p2pIp: S.String.pipe(T.Body("p2p_ip")),
    bgp: S.optional(S.NullOr(CnisUpdateResponseBgp)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateCniResponse",
}) as any as S.Schema<UpdateCniResponse>;

export type CreateCniError = CloudflareOpError;
/** Create a new CNI object */
export const createCni: API.OperationMethod<
  CreateCniRequest,
  CreateCniResponse,
  CreateCniError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateCniRequest,
  output: CreateCniResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateInterconnectError = CloudflareOpError;
/** Create a new interconnect */
export const createInterconnect: API.OperationMethod<
  CreateInterconnectRequest,
  CreateInterconnectResponse,
  CreateInterconnectError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateInterconnectRequest,
  output: CreateInterconnectResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteCniError = CloudflareOpError;
/** Delete a specified CNI object */
export const deleteCni: API.OperationMethod<
  DeleteCniRequest,
  DeleteCniResponse,
  DeleteCniError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteCniRequest,
  output: DeleteCniResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteInterconnectError = CloudflareOpError;
/** Delete an interconnect object */
export const deleteInterconnect: API.OperationMethod<
  DeleteInterconnectRequest,
  DeleteInterconnectResponse,
  DeleteInterconnectError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteInterconnectRequest,
  output: DeleteInterconnectResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetCniError = CloudflareOpError;
/** Get information about a CNI object */
export const getCni: API.OperationMethod<
  GetCniRequest,
  GetCniResponse,
  GetCniError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetCniRequest,
  output: GetCniResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetInterconnectError = CloudflareOpError;
/** Get information about an interconnect object */
export const getInterconnect: API.OperationMethod<
  GetInterconnectRequest,
  GetInterconnectResponse,
  GetInterconnectError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetInterconnectRequest,
  output: GetInterconnectResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetSettingError = Forbidden | CloudflareOpError;
/** Get the current settings for the active account */
export const getSetting: API.OperationMethod<
  GetSettingRequest,
  GetSettingResponse,
  GetSettingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetSettingRequest,
  output: GetSettingResponse,
  errors: [Forbidden, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetSlotError = CloudflareOpError;
/** Get information about the specified slot */
export const getSlot: API.OperationMethod<
  GetSlotRequest,
  GetSlotResponse,
  GetSlotError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetSlotRequest,
  output: GetSlotResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListCnisError = CloudflareOpError;
/** List existing CNI objects */
export const listCnis: API.OperationMethod<
  ListCnisRequest,
  ListCnisResponse,
  ListCnisError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListCnisRequest,
  output: ListCnisResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListInterconnectsError = CloudflareOpError;
/** List existing interconnects */
export const listInterconnects: API.OperationMethod<
  ListInterconnectsRequest,
  ListInterconnectsResponse,
  ListInterconnectsError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListInterconnectsRequest,
  output: ListInterconnectsResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListSlotsError = CloudflareOpError;
/** Retrieve a list of all slots matching the specified parameters */
export const listSlots: API.OperationMethod<
  ListSlotsRequest,
  ListSlotsResponse,
  ListSlotsError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListSlotsRequest,
  output: ListSlotsResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type LoaInterconnectError = CloudflareOpError;
/** Generate the Letter of Authorization (LOA) for a given interconnect */
export const loaInterconnect: API.OperationMethod<
  LoaInterconnectRequest,
  LoaInterconnectResponse,
  LoaInterconnectError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: LoaInterconnectRequest,
  output: LoaInterconnectResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PutSettingError = Forbidden | CloudflareOpError;
/** Update the current settings for the active account */
export const putSetting: API.OperationMethod<
  PutSettingRequest,
  PutSettingResponse,
  PutSettingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PutSettingRequest,
  output: PutSettingResponse,
  errors: [Forbidden, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type StatusInterconnectError = CloudflareOpError;
/** Get the current status of an interconnect object */
export const statusInterconnect: API.OperationMethod<
  StatusInterconnectRequest,
  StatusInterconnectResponse,
  StatusInterconnectError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: StatusInterconnectRequest,
  output: StatusInterconnectResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type UpdateCniError = CloudflareOpError;
/** Modify stored information about a CNI object */
export const updateCni: API.OperationMethod<
  UpdateCniRequest,
  UpdateCniResponse,
  UpdateCniError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: UpdateCniRequest,
  output: UpdateCniResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));