/**
 * 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 type { Credentials } from "../credentials.ts";
import { type DefaultErrors } from "../errors.ts";
export interface GetCniRequest {
    cni: string;
    /** Customer account tag */
    accountId: string;
}
export declare const GetCniRequest: 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 declare const GetCniResponse: Schema.Schema<GetCniResponse>;
export type GetCniError = DefaultErrors;
export declare const getCni: API.OperationMethod<GetCniRequest, GetCniResponse, GetCniError, Credentials | HttpClient.HttpClient>;
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 declare const ListCnisRequest: 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 declare const ListCnisResponse: Schema.Schema<ListCnisResponse>;
export type ListCnisError = DefaultErrors;
export declare const listCnis: API.OperationMethod<ListCnisRequest, ListCnisResponse, ListCnisError, Credentials | HttpClient.HttpClient>;
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 declare const CreateCniRequest: 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 declare const CreateCniResponse: Schema.Schema<CreateCniResponse>;
export type CreateCniError = DefaultErrors;
export declare const createCni: API.OperationMethod<CreateCniRequest, CreateCniResponse, CreateCniError, Credentials | HttpClient.HttpClient>;
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 declare const UpdateCniRequest: 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 declare const UpdateCniResponse: Schema.Schema<UpdateCniResponse>;
export type UpdateCniError = DefaultErrors;
export declare const updateCni: API.OperationMethod<UpdateCniRequest, UpdateCniResponse, UpdateCniError, Credentials | HttpClient.HttpClient>;
export interface DeleteCniRequest {
    cni: string;
    /** Customer account tag */
    accountId: string;
}
export declare const DeleteCniRequest: Schema.Schema<DeleteCniRequest>;
export type DeleteCniResponse = unknown;
export declare const DeleteCniResponse: Schema.Schema<DeleteCniResponse>;
export type DeleteCniError = DefaultErrors;
export declare const deleteCni: API.OperationMethod<DeleteCniRequest, DeleteCniResponse, DeleteCniError, Credentials | HttpClient.HttpClient>;
export interface GetInterconnectRequest {
    icon: string;
    /** Customer account tag */
    accountId: string;
}
export declare const GetInterconnectRequest: 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 declare const GetInterconnectResponse: Schema.Schema<GetInterconnectResponse>;
export type GetInterconnectError = DefaultErrors;
export declare const getInterconnect: API.OperationMethod<GetInterconnectRequest, GetInterconnectResponse, GetInterconnectError, Credentials | HttpClient.HttpClient>;
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 declare const ListInterconnectsRequest: 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 declare const ListInterconnectsResponse: Schema.Schema<ListInterconnectsResponse>;
export type ListInterconnectsError = DefaultErrors;
export declare const listInterconnects: API.OperationMethod<ListInterconnectsRequest, ListInterconnectsResponse, ListInterconnectsError, Credentials | HttpClient.HttpClient>;
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 declare const CreateInterconnectRequest: 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 declare const CreateInterconnectResponse: Schema.Schema<CreateInterconnectResponse>;
export type CreateInterconnectError = DefaultErrors;
export declare const createInterconnect: API.OperationMethod<CreateInterconnectRequest, CreateInterconnectResponse, CreateInterconnectError, Credentials | HttpClient.HttpClient>;
export interface DeleteInterconnectRequest {
    icon: string;
    /** Customer account tag */
    accountId: string;
}
export declare const DeleteInterconnectRequest: Schema.Schema<DeleteInterconnectRequest>;
export type DeleteInterconnectResponse = unknown;
export declare const DeleteInterconnectResponse: Schema.Schema<DeleteInterconnectResponse>;
export type DeleteInterconnectError = DefaultErrors;
export declare const deleteInterconnect: API.OperationMethod<DeleteInterconnectRequest, DeleteInterconnectResponse, DeleteInterconnectError, Credentials | HttpClient.HttpClient>;
export interface StatusInterconnectRequest {
    icon: string;
    /** Customer account tag */
    accountId: string;
}
export declare const StatusInterconnectRequest: Schema.Schema<StatusInterconnectRequest>;
export type StatusInterconnectResponse = {
    state: "Pending";
} | {
    state: "Down";
    reason?: string | null;
} | {
    state: "Unhealthy";
    reason?: string | null;
} | {
    state: "Healthy";
};
export declare const StatusInterconnectResponse: Schema.Schema<StatusInterconnectResponse>;
export type StatusInterconnectError = DefaultErrors;
export declare const statusInterconnect: API.OperationMethod<StatusInterconnectRequest, StatusInterconnectResponse, StatusInterconnectError, Credentials | HttpClient.HttpClient>;
export interface LoaInterconnectRequest {
    icon: string;
    /** Customer account tag */
    accountId: string;
}
export declare const LoaInterconnectRequest: Schema.Schema<LoaInterconnectRequest>;
export type LoaInterconnectResponse = unknown;
export declare const LoaInterconnectResponse: Schema.Schema<LoaInterconnectResponse>;
export type LoaInterconnectError = DefaultErrors;
export declare const loaInterconnect: API.OperationMethod<LoaInterconnectRequest, LoaInterconnectResponse, LoaInterconnectError, Credentials | HttpClient.HttpClient>;
export interface GetSettingRequest {
    /** Account tag to retrieve settings for */
    accountId: string;
}
export declare const GetSettingRequest: Schema.Schema<GetSettingRequest>;
export interface GetSettingResponse {
    defaultAsn: number;
}
export declare const GetSettingResponse: Schema.Schema<GetSettingResponse>;
export type GetSettingError = DefaultErrors;
export declare const getSetting: API.OperationMethod<GetSettingRequest, GetSettingResponse, GetSettingError, Credentials | HttpClient.HttpClient>;
export interface PutSettingRequest {
    /** Path param: Account tag to update settings for */
    accountId: string;
    /** Body param: */
    defaultAsn?: number | null;
}
export declare const PutSettingRequest: Schema.Schema<PutSettingRequest>;
export interface PutSettingResponse {
    defaultAsn: number;
}
export declare const PutSettingResponse: Schema.Schema<PutSettingResponse>;
export type PutSettingError = DefaultErrors;
export declare const putSetting: API.OperationMethod<PutSettingRequest, PutSettingResponse, PutSettingError, Credentials | HttpClient.HttpClient>;
export interface GetSlotRequest {
    slot: string;
    /** Customer account tag */
    accountId: string;
}
export declare const GetSlotRequest: 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 declare const GetSlotResponse: Schema.Schema<GetSlotResponse>;
export type GetSlotError = DefaultErrors;
export declare const getSlot: API.OperationMethod<GetSlotRequest, GetSlotResponse, GetSlotError, Credentials | HttpClient.HttpClient>;
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 declare const ListSlotsRequest: 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 declare const ListSlotsResponse: Schema.Schema<ListSlotsResponse>;
export type ListSlotsError = DefaultErrors;
export declare const listSlots: API.OperationMethod<ListSlotsRequest, ListSlotsResponse, ListSlotsError, Credentials | HttpClient.HttpClient>;
//# sourceMappingURL=network-interconnects.d.ts.map