@distilled.cloud/cloudflare 0.0.0 → 0.2.0-alpha

package/lib/services/magic-transit.d.ts

@@ -0,0 +1,3650 @@
+/**
+ * Cloudflare MAGIC-TRANSIT API
+ *
+ * Generated from Cloudflare TypeScript SDK.
+ * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service magic-transit
+ */
+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";
+import { type DefaultErrors } from "../errors";
+export interface ListAppsRequest {
+    /** Identifier */
+    accountId: string;
+}
+export declare const ListAppsRequest: Schema.Schema<ListAppsRequest>;
+export type ListAppsResponse = ({
+    accountAppId: string;
+    hostnames?: string[] | null;
+    ipSubnets?: string[] | null;
+    name?: string | null;
+    type?: string | null;
+} | {
+    managedAppId: string;
+    hostnames?: string[] | null;
+    ipSubnets?: string[] | null;
+    name?: string | null;
+    type?: string | null;
+})[];
+export declare const ListAppsResponse: Schema.Schema<ListAppsResponse>;
+export type ListAppsError = DefaultErrors;
+export declare const listApps: API.OperationMethod<ListAppsRequest, ListAppsResponse, ListAppsError, Credentials | HttpClient.HttpClient>;
+export interface CreateAppRequest {
+    /** Path param: Identifier */
+    accountId: string;
+    /** Body param: Display name for the app. */
+    name: string;
+    /** Body param: Category of the app. */
+    type: string;
+    /** Body param: FQDNs to associate with traffic decisions. */
+    hostnames?: string[];
+    /** Body param: IPv4 CIDRs to associate with traffic decisions. (IPv6 CIDRs are currently unsupported) */
+    ipSubnets?: string[];
+}
+export declare const CreateAppRequest: Schema.Schema<CreateAppRequest>;
+export interface CreateAppResponse {
+    /** Magic account app ID. */
+    accountAppId: string;
+    /** FQDNs to associate with traffic decisions. */
+    hostnames?: string[] | null;
+    /** IPv4 CIDRs to associate with traffic decisions. (IPv6 CIDRs are currently unsupported) */
+    ipSubnets?: string[] | null;
+    /** Display name for the app. */
+    name?: string | null;
+    /** Category of the app. */
+    type?: string | null;
+}
+export declare const CreateAppResponse: Schema.Schema<CreateAppResponse>;
+export type CreateAppError = DefaultErrors;
+export declare const createApp: API.OperationMethod<CreateAppRequest, CreateAppResponse, CreateAppError, Credentials | HttpClient.HttpClient>;
+export interface UpdateAppRequest {
+    accountAppId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Body param: FQDNs to associate with traffic decisions. */
+    hostnames?: string[];
+    /** Body param: IPv4 CIDRs to associate with traffic decisions. (IPv6 CIDRs are currently unsupported) */
+    ipSubnets?: string[];
+    /** Body param: Display name for the app. */
+    name?: string;
+    /** Body param: Category of the app. */
+    type?: string;
+}
+export declare const UpdateAppRequest: Schema.Schema<UpdateAppRequest>;
+export interface UpdateAppResponse {
+    /** Magic account app ID. */
+    accountAppId: string;
+    /** FQDNs to associate with traffic decisions. */
+    hostnames?: string[] | null;
+    /** IPv4 CIDRs to associate with traffic decisions. (IPv6 CIDRs are currently unsupported) */
+    ipSubnets?: string[] | null;
+    /** Display name for the app. */
+    name?: string | null;
+    /** Category of the app. */
+    type?: string | null;
+}
+export declare const UpdateAppResponse: Schema.Schema<UpdateAppResponse>;
+export type UpdateAppError = DefaultErrors;
+export declare const updateApp: API.OperationMethod<UpdateAppRequest, UpdateAppResponse, UpdateAppError, Credentials | HttpClient.HttpClient>;
+export interface PatchAppRequest {
+    accountAppId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Body param: FQDNs to associate with traffic decisions. */
+    hostnames?: string[];
+    /** Body param: IPv4 CIDRs to associate with traffic decisions. (IPv6 CIDRs are currently unsupported) */
+    ipSubnets?: string[];
+    /** Body param: Display name for the app. */
+    name?: string;
+    /** Body param: Category of the app. */
+    type?: string;
+}
+export declare const PatchAppRequest: Schema.Schema<PatchAppRequest>;
+export interface PatchAppResponse {
+    /** Magic account app ID. */
+    accountAppId: string;
+    /** FQDNs to associate with traffic decisions. */
+    hostnames?: string[] | null;
+    /** IPv4 CIDRs to associate with traffic decisions. (IPv6 CIDRs are currently unsupported) */
+    ipSubnets?: string[] | null;
+    /** Display name for the app. */
+    name?: string | null;
+    /** Category of the app. */
+    type?: string | null;
+}
+export declare const PatchAppResponse: Schema.Schema<PatchAppResponse>;
+export type PatchAppError = DefaultErrors;
+export declare const patchApp: API.OperationMethod<PatchAppRequest, PatchAppResponse, PatchAppError, Credentials | HttpClient.HttpClient>;
+export interface DeleteAppRequest {
+    accountAppId: string;
+    /** Identifier */
+    accountId: string;
+}
+export declare const DeleteAppRequest: Schema.Schema<DeleteAppRequest>;
+export interface DeleteAppResponse {
+    /** Magic account app ID. */
+    accountAppId: string;
+    /** FQDNs to associate with traffic decisions. */
+    hostnames?: string[] | null;
+    /** IPv4 CIDRs to associate with traffic decisions. (IPv6 CIDRs are currently unsupported) */
+    ipSubnets?: string[] | null;
+    /** Display name for the app. */
+    name?: string | null;
+    /** Category of the app. */
+    type?: string | null;
+}
+export declare const DeleteAppResponse: Schema.Schema<DeleteAppResponse>;
+export type DeleteAppError = DefaultErrors;
+export declare const deleteApp: API.OperationMethod<DeleteAppRequest, DeleteAppResponse, DeleteAppError, Credentials | HttpClient.HttpClient>;
+export interface GetCfInterconnectRequest {
+    cfInterconnectId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Header param: If true, the health check target in the response body will be presented using the new object format. Defaults to false. */
+    xMagicNewHcTarget?: boolean;
+}
+export declare const GetCfInterconnectRequest: Schema.Schema<GetCfInterconnectRequest>;
+export interface GetCfInterconnectResponse {
+    interconnect?: {
+        id?: string | null;
+        automaticReturnRouting?: boolean | null;
+        coloName?: string | null;
+        createdOn?: string | null;
+        description?: string | null;
+        gre?: {
+            cloudflareEndpoint?: string | null;
+        } | null;
+        healthCheck?: unknown | null;
+        interfaceAddress?: string | null;
+        interfaceAddress6?: string | null;
+        modifiedOn?: string | null;
+        mtu?: number | null;
+        name?: string | null;
+    } | null;
+}
+export declare const GetCfInterconnectResponse: Schema.Schema<GetCfInterconnectResponse>;
+export type GetCfInterconnectError = DefaultErrors;
+export declare const getCfInterconnect: API.OperationMethod<GetCfInterconnectRequest, GetCfInterconnectResponse, GetCfInterconnectError, Credentials | HttpClient.HttpClient>;
+export interface ListCfInterconnectsRequest {
+    /** Path param: Identifier */
+    accountId: string;
+    /** Header param: If true, the health check target in the response body will be presented using the new object format. Defaults to false. */
+    xMagicNewHcTarget?: boolean;
+}
+export declare const ListCfInterconnectsRequest: Schema.Schema<ListCfInterconnectsRequest>;
+export interface ListCfInterconnectsResponse {
+    interconnects?: {
+        id?: string | null;
+        automaticReturnRouting?: boolean | null;
+        coloName?: string | null;
+        createdOn?: string | null;
+        description?: string | null;
+        gre?: {
+            cloudflareEndpoint?: string | null;
+        } | null;
+        healthCheck?: unknown | null;
+        interfaceAddress?: string | null;
+        interfaceAddress6?: string | null;
+        modifiedOn?: string | null;
+        mtu?: number | null;
+        name?: string | null;
+    }[] | null;
+}
+export declare const ListCfInterconnectsResponse: Schema.Schema<ListCfInterconnectsResponse>;
+export type ListCfInterconnectsError = DefaultErrors;
+export declare const listCfInterconnects: API.OperationMethod<ListCfInterconnectsRequest, ListCfInterconnectsResponse, ListCfInterconnectsError, Credentials | HttpClient.HttpClient>;
+export interface PutCfInterconnectRequest {
+    cfInterconnectId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Header param: If true, the health check target in the request and response bodies will be presented using the new object format. Defaults to false. */
+    xMagicNewHcTarget?: boolean;
+    /** Body param: True if automatic stateful return routing should be enabled for a tunnel, false otherwise. */
+    automaticReturnRouting?: boolean;
+    /** Body param: An optional description of the interconnect. */
+    description?: string;
+    /** Body param: The configuration specific to GRE interconnects. */
+    gre?: {
+        cloudflareEndpoint?: string;
+    };
+    /** Body param: */
+    healthCheck?: unknown;
+    /** Body param: A 31-bit prefix (/31 in CIDR notation) supporting two hosts, one for each side of the tunnel. Select the subnet from the following private IP space: 10.0.0.0–10.255.255.255, 172.16.0.0–172 */
+    interfaceAddress?: string;
+    /** Body param: A 127 bit IPV6 prefix from within the virtual_subnet6 prefix space with the address being the first IP of the subnet and not same as the address of virtual_subnet6. Eg if virtual_subnet6 i */
+    interfaceAddress6?: string;
+    /** Body param: The Maximum Transmission Unit (MTU) in bytes for the interconnect. The minimum value is 576. */
+    mtu?: number;
+}
+export declare const PutCfInterconnectRequest: Schema.Schema<PutCfInterconnectRequest>;
+export interface PutCfInterconnectResponse {
+    modified?: boolean | null;
+    modifiedInterconnect?: {
+        id?: string | null;
+        automaticReturnRouting?: boolean | null;
+        coloName?: string | null;
+        createdOn?: string | null;
+        description?: string | null;
+        gre?: {
+            cloudflareEndpoint?: string | null;
+        } | null;
+        healthCheck?: unknown | null;
+        interfaceAddress?: string | null;
+        interfaceAddress6?: string | null;
+        modifiedOn?: string | null;
+        mtu?: number | null;
+        name?: string | null;
+    } | null;
+}
+export declare const PutCfInterconnectResponse: Schema.Schema<PutCfInterconnectResponse>;
+export type PutCfInterconnectError = DefaultErrors;
+export declare const putCfInterconnect: API.OperationMethod<PutCfInterconnectRequest, PutCfInterconnectResponse, PutCfInterconnectError, Credentials | HttpClient.HttpClient>;
+export interface GetConnectorRequest {
+    connectorId: string;
+    /** Account identifier */
+    accountId: string;
+}
+export declare const GetConnectorRequest: Schema.Schema<GetConnectorRequest>;
+export interface GetConnectorResponse {
+    id: string;
+    activated: boolean;
+    interruptWindowDurationHours: number;
+    interruptWindowHourOfDay: number;
+    lastUpdated: string;
+    notes: string;
+    timezone: string;
+    device?: {
+        id: string;
+        serialNumber?: string | null;
+    } | null;
+    lastHeartbeat?: string | null;
+    lastSeenVersion?: string | null;
+    licenseKey?: string | null;
+}
+export declare const GetConnectorResponse: Schema.Schema<GetConnectorResponse>;
+export type GetConnectorError = DefaultErrors;
+export declare const getConnector: API.OperationMethod<GetConnectorRequest, GetConnectorResponse, GetConnectorError, Credentials | HttpClient.HttpClient>;
+export interface ListConnectorsRequest {
+    /** Account identifier */
+    accountId: string;
+}
+export declare const ListConnectorsRequest: Schema.Schema<ListConnectorsRequest>;
+export type ListConnectorsResponse = {
+    id: string;
+    activated: boolean;
+    interruptWindowDurationHours: number;
+    interruptWindowHourOfDay: number;
+    lastUpdated: string;
+    notes: string;
+    timezone: string;
+    device?: {
+        id: string;
+        serialNumber?: string | null;
+    } | null;
+    lastHeartbeat?: string | null;
+    lastSeenVersion?: string | null;
+    licenseKey?: string | null;
+}[];
+export declare const ListConnectorsResponse: Schema.Schema<ListConnectorsResponse>;
+export type ListConnectorsError = DefaultErrors;
+export declare const listConnectors: API.OperationMethod<ListConnectorsRequest, ListConnectorsResponse, ListConnectorsError, Credentials | HttpClient.HttpClient>;
+export interface CreateConnectorRequest {
+    /** Path param: Account identifier */
+    accountId: string;
+    /** Body param: Exactly one of id, serial_number, or provision_license must be provided. */
+    device: {
+        id?: string;
+        provisionLicense?: boolean;
+        serialNumber?: string;
+    };
+    /** Body param: */
+    activated?: boolean;
+    /** Body param: */
+    interruptWindowDurationHours?: number;
+    /** Body param: */
+    interruptWindowHourOfDay?: number;
+    /** Body param: */
+    notes?: string;
+    /** Body param: */
+    timezone?: string;
+}
+export declare const CreateConnectorRequest: Schema.Schema<CreateConnectorRequest>;
+export interface CreateConnectorResponse {
+    id: string;
+    activated: boolean;
+    interruptWindowDurationHours: number;
+    interruptWindowHourOfDay: number;
+    lastUpdated: string;
+    notes: string;
+    timezone: string;
+    device?: {
+        id: string;
+        serialNumber?: string | null;
+    } | null;
+    lastHeartbeat?: string | null;
+    lastSeenVersion?: string | null;
+    licenseKey?: string | null;
+}
+export declare const CreateConnectorResponse: Schema.Schema<CreateConnectorResponse>;
+export type CreateConnectorError = DefaultErrors;
+export declare const createConnector: API.OperationMethod<CreateConnectorRequest, CreateConnectorResponse, CreateConnectorError, Credentials | HttpClient.HttpClient>;
+export interface UpdateConnectorRequest {
+    connectorId: string;
+    /** Path param: Account identifier */
+    accountId: string;
+    /** Body param: */
+    activated?: boolean;
+    /** Body param: */
+    interruptWindowDurationHours?: number;
+    /** Body param: */
+    interruptWindowHourOfDay?: number;
+    /** Body param: */
+    notes?: string;
+    /** Body param: When true, regenerate license key for the connector. */
+    provisionLicense?: boolean;
+    /** Body param: */
+    timezone?: string;
+}
+export declare const UpdateConnectorRequest: Schema.Schema<UpdateConnectorRequest>;
+export interface UpdateConnectorResponse {
+    id: string;
+    activated: boolean;
+    interruptWindowDurationHours: number;
+    interruptWindowHourOfDay: number;
+    lastUpdated: string;
+    notes: string;
+    timezone: string;
+    device?: {
+        id: string;
+        serialNumber?: string | null;
+    } | null;
+    lastHeartbeat?: string | null;
+    lastSeenVersion?: string | null;
+    licenseKey?: string | null;
+}
+export declare const UpdateConnectorResponse: Schema.Schema<UpdateConnectorResponse>;
+export type UpdateConnectorError = DefaultErrors;
+export declare const updateConnector: API.OperationMethod<UpdateConnectorRequest, UpdateConnectorResponse, UpdateConnectorError, Credentials | HttpClient.HttpClient>;
+export interface PatchConnectorRequest {
+    connectorId: string;
+    /** Path param: Account identifier */
+    accountId: string;
+    /** Body param: */
+    activated?: boolean;
+    /** Body param: */
+    interruptWindowDurationHours?: number;
+    /** Body param: */
+    interruptWindowHourOfDay?: number;
+    /** Body param: */
+    notes?: string;
+    /** Body param: When true, regenerate license key for the connector. */
+    provisionLicense?: boolean;
+    /** Body param: */
+    timezone?: string;
+}
+export declare const PatchConnectorRequest: Schema.Schema<PatchConnectorRequest>;
+export interface PatchConnectorResponse {
+    id: string;
+    activated: boolean;
+    interruptWindowDurationHours: number;
+    interruptWindowHourOfDay: number;
+    lastUpdated: string;
+    notes: string;
+    timezone: string;
+    device?: {
+        id: string;
+        serialNumber?: string | null;
+    } | null;
+    lastHeartbeat?: string | null;
+    lastSeenVersion?: string | null;
+    licenseKey?: string | null;
+}
+export declare const PatchConnectorResponse: Schema.Schema<PatchConnectorResponse>;
+export type PatchConnectorError = DefaultErrors;
+export declare const patchConnector: API.OperationMethod<PatchConnectorRequest, PatchConnectorResponse, PatchConnectorError, Credentials | HttpClient.HttpClient>;
+export interface DeleteConnectorRequest {
+    connectorId: string;
+    /** Account identifier */
+    accountId: string;
+}
+export declare const DeleteConnectorRequest: Schema.Schema<DeleteConnectorRequest>;
+export interface DeleteConnectorResponse {
+    id: string;
+    activated: boolean;
+    interruptWindowDurationHours: number;
+    interruptWindowHourOfDay: number;
+    lastUpdated: string;
+    notes: string;
+    timezone: string;
+    device?: {
+        id: string;
+        serialNumber?: string | null;
+    } | null;
+    lastHeartbeat?: string | null;
+    lastSeenVersion?: string | null;
+    licenseKey?: string | null;
+}
+export declare const DeleteConnectorResponse: Schema.Schema<DeleteConnectorResponse>;
+export type DeleteConnectorError = DefaultErrors;
+export declare const deleteConnector: API.OperationMethod<DeleteConnectorRequest, DeleteConnectorResponse, DeleteConnectorError, Credentials | HttpClient.HttpClient>;
+export interface GetConnectorEventRequest {
+    connectorId: string;
+    eventT: number;
+    eventN: number;
+    /** Account identifier */
+    accountId: string;
+}
+export declare const GetConnectorEventRequest: Schema.Schema<GetConnectorEventRequest>;
+export interface GetConnectorEventResponse {
+    e: {
+        k: "Init";
+    } | {
+        k: "Leave";
+    } | {
+        k: "StartAttestation";
+    } | {
+        k: "FinishAttestationSuccess";
+    } | {
+        k: "FinishAttestationFailure";
+    } | {
+        k: "StartRotateCryptKey";
+    } | {
+        k: "FinishRotateCryptKeySuccess";
+    } | {
+        k: "FinishRotateCryptKeyFailure";
+    } | {
+        k: "StartRotatePki";
+    } | {
+        k: "FinishRotatePkiSuccess";
+    } | {
+        k: "FinishRotatePkiFailure";
+    } | {
+        k: "StartUpgrade";
+        url: string;
+    } | {
+        k: "FinishUpgradeSuccess";
+    } | {
+        k: "FinishUpgradeFailure";
+    } | {
+        k: "Reconcile";
+    } | {
+        k: "ConfigureCloudflaredTunnel";
+    };
+    /** Sequence number, used to order events with the same timestamp */
+    n: number;
+    /** Time the Event was recorded (seconds since the Unix epoch) */
+    t: number;
+}
+export declare const GetConnectorEventResponse: Schema.Schema<GetConnectorEventResponse>;
+export type GetConnectorEventError = DefaultErrors;
+export declare const getConnectorEvent: API.OperationMethod<GetConnectorEventRequest, GetConnectorEventResponse, GetConnectorEventError, Credentials | HttpClient.HttpClient>;
+export interface ListConnectorEventsRequest {
+    connectorId: string;
+    /** Path param: Account identifier */
+    accountId: string;
+    /** Query param: */
+    from: number;
+    /** Query param: */
+    to: number;
+    /** Query param: */
+    cursor?: string;
+    /** Query param: Filter by event kind */
+    k?: string;
+    /** Query param: */
+    limit?: number;
+}
+export declare const ListConnectorEventsRequest: Schema.Schema<ListConnectorEventsRequest>;
+export interface ListConnectorEventsResponse {
+    count: number;
+    items: {
+        a: number;
+        k: string;
+        n: number;
+        t: number;
+    }[];
+    cursor?: string | null;
+}
+export declare const ListConnectorEventsResponse: Schema.Schema<ListConnectorEventsResponse>;
+export type ListConnectorEventsError = DefaultErrors;
+export declare const listConnectorEvents: API.OperationMethod<ListConnectorEventsRequest, ListConnectorEventsResponse, ListConnectorEventsError, Credentials | HttpClient.HttpClient>;
+export interface ListConnectorEventLatestsRequest {
+    connectorId: string;
+    /** Account identifier */
+    accountId: string;
+}
+export declare const ListConnectorEventLatestsRequest: Schema.Schema<ListConnectorEventLatestsRequest>;
+export interface ListConnectorEventLatestsResponse {
+    count: number;
+    items: {
+        e: {
+            k: "Init";
+        } | {
+            k: "Leave";
+        } | {
+            k: "StartAttestation";
+        } | {
+            k: "FinishAttestationSuccess";
+        } | {
+            k: "FinishAttestationFailure";
+        } | {
+            k: "StartRotateCryptKey";
+        } | {
+            k: "FinishRotateCryptKeySuccess";
+        } | {
+            k: "FinishRotateCryptKeyFailure";
+        } | {
+            k: "StartRotatePki";
+        } | {
+            k: "FinishRotatePkiSuccess";
+        } | {
+            k: "FinishRotatePkiFailure";
+        } | {
+            k: "StartUpgrade";
+            url: string;
+        } | {
+            k: "FinishUpgradeSuccess";
+        } | {
+            k: "FinishUpgradeFailure";
+        } | {
+            k: "Reconcile";
+        } | {
+            k: "ConfigureCloudflaredTunnel";
+        };
+        n: number;
+        t: number;
+    }[];
+}
+export declare const ListConnectorEventLatestsResponse: Schema.Schema<ListConnectorEventLatestsResponse>;
+export type ListConnectorEventLatestsError = DefaultErrors;
+export declare const listConnectorEventLatests: API.OperationMethod<ListConnectorEventLatestsRequest, ListConnectorEventLatestsResponse, ListConnectorEventLatestsError, Credentials | HttpClient.HttpClient>;
+export interface GetConnectorSnapshotRequest {
+    connectorId: string;
+    snapshotT: number;
+    /** Account identifier */
+    accountId: string;
+}
+export declare const GetConnectorSnapshotRequest: Schema.Schema<GetConnectorSnapshotRequest>;
+export interface GetConnectorSnapshotResponse {
+    /** Count of failures to reclaim space */
+    countReclaimFailures: number;
+    /** Count of reclaimed paths */
+    countReclaimedPaths: number;
+    /** Count of failed snapshot recordings */
+    countRecordFailed: number;
+    /** Count of failed snapshot transmissions */
+    countTransmitFailures: number;
+    /** Time the Snapshot was recorded (seconds since the Unix epoch) */
+    t: number;
+    /** Version */
+    v: string;
+    bonds?: {
+        name: string;
+        status: string;
+    }[] | null;
+    /** Count of processors/cores */
+    cpuCount?: number | null;
+    /** Percentage of time over a 10 second window that tasks were stalled */
+    cpuPressure_10s?: number | null;
+    /** Percentage of time over a 5 minute window that tasks were stalled */
+    cpuPressure_300s?: number | null;
+    /** Percentage of time over a 1 minute window that tasks were stalled */
+    cpuPressure_60s?: number | null;
+    /** Total stall time (microseconds) */
+    cpuPressureTotalUs?: number | null;
+    /** Time spent running a virtual CPU or guest OS (milliseconds) */
+    cpuTimeGuestMs?: number | null;
+    /** Time spent running a niced guest (milliseconds) */
+    cpuTimeGuestNiceMs?: number | null;
+    /** Time spent in idle state (milliseconds) */
+    cpuTimeIdleMs?: number | null;
+    /** Time spent wait for I/O to complete (milliseconds) */
+    cpuTimeIowaitMs?: number | null;
+    /** Time spent servicing interrupts (milliseconds) */
+    cpuTimeIrqMs?: number | null;
+    /** Time spent in low-priority user mode (milliseconds) */
+    cpuTimeNiceMs?: number | null;
+    /** Time spent servicing softirqs (milliseconds) */
+    cpuTimeSoftirqMs?: number | null;
+    /** Time stolen (milliseconds) */
+    cpuTimeStealMs?: number | null;
+    /** Time spent in system mode (milliseconds) */
+    cpuTimeSystemMs?: number | null;
+    /** Time spent in user mode (milliseconds) */
+    cpuTimeUserMs?: number | null;
+    dhcpLeases?: {
+        clientId: string;
+        expiryTime: number;
+        hostname: string;
+        interfaceName: string;
+        ipAddress: string;
+        macAddress: string;
+        connectorId?: string | null;
+    }[] | null;
+    disks?: {
+        inProgress: number;
+        major: number;
+        merged: number;
+        minor: number;
+        name: string;
+        reads: number;
+        sectorsRead: number;
+        sectorsWritten: number;
+        timeInProgressMs: number;
+        timeReadingMs: number;
+        timeWritingMs: number;
+        weightedTimeInProgressMs: number;
+        writes: number;
+        writesMerged: number;
+        connectorId?: string | null;
+        discards?: number | null;
+        discardsMerged?: number | null;
+        flushes?: number | null;
+        sectorsDiscarded?: number | null;
+        timeDiscardingMs?: number | null;
+        timeFlushingMs?: number | null;
+    }[] | null;
+    /** Name of high availability state */
+    haState?: string | null;
+    /** Numeric value associated with high availability state (0 = disabled, 1 = active, 2 = standby, 3 = stopped, 4 = fault) */
+    haValue?: number | null;
+    interfaces?: {
+        name: string;
+        operstate: string;
+        connectorId?: string | null;
+        ipAddresses?: {
+            interfaceName: string;
+            ipAddress: string;
+            connectorId?: string | null;
+        }[] | null;
+        speed?: number | null;
+    }[] | null;
+    /** Percentage of time over a 10 second window that all tasks were stalled */
+    ioPressureFull_10s?: number | null;
+    /** Percentage of time over a 5 minute window that all tasks were stalled */
+    ioPressureFull_300s?: number | null;
+    /** Percentage of time over a 1 minute window that all tasks were stalled */
+    ioPressureFull_60s?: number | null;
+    /** Total stall time (microseconds) */
+    ioPressureFullTotalUs?: number | null;
+    /** Percentage of time over a 10 second window that some tasks were stalled */
+    ioPressureSome_10s?: number | null;
+    /** Percentage of time over a 3 minute window that some tasks were stalled */
+    ioPressureSome_300s?: number | null;
+    /** Percentage of time over a 1 minute window that some tasks were stalled */
+    ioPressureSome_60s?: number | null;
+    /** Total stall time (microseconds) */
+    ioPressureSomeTotalUs?: number | null;
+    /** Boot time (seconds since Unix epoch) */
+    kernelBtime?: number | null;
+    /** Number of context switches that the system underwent */
+    kernelCtxt?: number | null;
+    /** Number of forks since boot */
+    kernelProcesses?: number | null;
+    /** Number of processes blocked waiting for I/O */
+    kernelProcessesBlocked?: number | null;
+    /** Number of processes in runnable state */
+    kernelProcessesRunning?: number | null;
+    /** The fifteen-minute load average */
+    loadAverage_15m?: number | null;
+    /** The one-minute load average */
+    loadAverage_1m?: number | null;
+    /** The five-minute load average */
+    loadAverage_5m?: number | null;
+    /** Number of currently runnable kernel scheduling entities */
+    loadAverageCur?: number | null;
+    /** Number of kernel scheduling entities that currently exist on the system */
+    loadAverageMax?: number | null;
+    /** Memory that has been used more recently */
+    memoryActiveBytes?: number | null;
+    /** Non-file backed huge pages mapped into user-space page tables */
+    memoryAnonHugepagesBytes?: number | null;
+    /** Non-file backed pages mapped into user-space page tables */
+    memoryAnonPagesBytes?: number | null;
+    /** Estimate of how much memory is available for starting new applications */
+    memoryAvailableBytes?: number | null;
+    /** Memory used for block device bounce buffers */
+    memoryBounceBytes?: number | null;
+    /** Relatively temporary storage for raw disk blocks */
+    memoryBuffersBytes?: number | null;
+    /** In-memory cache for files read from the disk */
+    memoryCachedBytes?: number | null;
+    /** Free CMA (Contiguous Memory Allocator) pages */
+    memoryCmaFreeBytes?: number | null;
+    /** Total CMA (Contiguous Memory Allocator) pages */
+    memoryCmaTotalBytes?: number | null;
+    /** Total amount of memory currently available to be allocated on the system */
+    memoryCommitLimitBytes?: number | null;
+    /** Amount of memory presently allocated on the system */
+    memoryCommittedAsBytes?: number | null;
+    /** Memory which is waiting to get written back to the disk */
+    memoryDirtyBytes?: number | null;
+    /** The sum of LowFree and HighFree */
+    memoryFreeBytes?: number | null;
+    /** Amount of free highmem */
+    memoryHighFreeBytes?: number | null;
+    /** Total amount of highmem */
+    memoryHighTotalBytes?: number | null;
+    /** The number of huge pages in the pool that are not yet allocated */
+    memoryHugepagesFree?: number | null;
+    /** Number of huge pages for which a commitment has been made, but no allocation has yet been made */
+    memoryHugepagesRsvd?: number | null;
+    /** Number of huge pages in the pool above the threshold */
+    memoryHugepagesSurp?: number | null;
+    /** The size of the pool of huge pages */
+    memoryHugepagesTotal?: number | null;
+    /** The size of huge pages */
+    memoryHugepagesizeBytes?: number | null;
+    /** Memory which has been less recently used */
+    memoryInactiveBytes?: number | null;
+    /** Kernel allocations that the kernel will attempt to reclaim under memory pressure */
+    memoryKReclaimableBytes?: number | null;
+    /** Amount of memory allocated to kernel stacks */
+    memoryKernelStackBytes?: number | null;
+    /** Amount of free lowmem */
+    memoryLowFreeBytes?: number | null;
+    /** Total amount of lowmem */
+    memoryLowTotalBytes?: number | null;
+    /** Files which have been mapped into memory */
+    memoryMappedBytes?: number | null;
+    /** Amount of memory dedicated to the lowest level of page tables */
+    memoryPageTablesBytes?: number | null;
+    /** Memory allocated to the per-cpu alloctor used to back per-cpu allocations */
+    memoryPerCpuBytes?: number | null;
+    /** Percentage of time over a 10 second window that all tasks were stalled */
+    memoryPressureFull_10s?: number | null;
+    /** Percentage of time over a 5 minute window that all tasks were stalled */
+    memoryPressureFull_300s?: number | null;
+    /** Percentage of time over a 1 minute window that all tasks were stalled */
+    memoryPressureFull_60s?: number | null;
+    /** Total stall time (microseconds) */
+    memoryPressureFullTotalUs?: number | null;
+    /** Percentage of time over a 10 second window that some tasks were stalled */
+    memoryPressureSome_10s?: number | null;
+    /** Percentage of time over a 5 minute window that some tasks were stalled */
+    memoryPressureSome_300s?: number | null;
+    /** Percentage of time over a 1 minute window that some tasks were stalled */
+    memoryPressureSome_60s?: number | null;
+    /** Total stall time (microseconds) */
+    memoryPressureSomeTotalUs?: number | null;
+    /** Part of slab that can be reclaimed on memory pressure */
+    memorySReclaimableBytes?: number | null;
+    /** Part of slab that cannot be reclaimed on memory pressure */
+    memorySUnreclaimBytes?: number | null;
+    /** Amount of memory dedicated to the lowest level of page tables */
+    memorySecondaryPageTablesBytes?: number | null;
+    /** Amount of memory consumed by tmpfs */
+    memoryShmemBytes?: number | null;
+    /** Memory used by shmem and tmpfs, allocated with huge pages */
+    memoryShmemHugepagesBytes?: number | null;
+    /** Shared memory mapped into user space with huge pages */
+    memoryShmemPmdMappedBytes?: number | null;
+    /** In-kernel data structures cache */
+    memorySlabBytes?: number | null;
+    /** Memory swapped out and back in while still in swap file */
+    memorySwapCachedBytes?: number | null;
+    /** Amount of swap space that is currently unused */
+    memorySwapFreeBytes?: number | null;
+    /** Total amount of swap space available */
+    memorySwapTotalBytes?: number | null;
+    /** Total usable RAM */
+    memoryTotalBytes?: number | null;
+    /** Largest contiguous block of vmalloc area which is free */
+    memoryVmallocChunkBytes?: number | null;
+    /** Total size of vmalloc memory area */
+    memoryVmallocTotalBytes?: number | null;
+    /** Amount of vmalloc area which is used */
+    memoryVmallocUsedBytes?: number | null;
+    /** Memory which is actively being written back to the disk */
+    memoryWritebackBytes?: number | null;
+    /** Memory used by FUSE for temporary writeback buffers */
+    memoryWritebackTmpBytes?: number | null;
+    /** Memory consumed by the zswap backend, compressed */
+    memoryZSwapBytes?: number | null;
+    /** Amount of anonymous memory stored in zswap, uncompressed */
+    memoryZSwappedBytes?: number | null;
+    mounts?: {
+        fileSystem: string;
+        kind: string;
+        mountPoint: string;
+        name: string;
+        availableBytes?: number | null;
+        connectorId?: string | null;
+        isReadOnly?: boolean | null;
+        isRemovable?: boolean | null;
+        totalBytes?: number | null;
+    }[] | null;
+    netdevs?: {
+        name: string;
+        recvBytes: number;
+        recvCompressed: number;
+        recvDrop: number;
+        recvErrs: number;
+        recvFifo: number;
+        recvFrame: number;
+        recvMulticast: number;
+        recvPackets: number;
+        sentBytes: number;
+        sentCarrier: number;
+        sentColls: number;
+        sentCompressed: number;
+        sentDrop: number;
+        sentErrs: number;
+        sentFifo: number;
+        sentPackets: number;
+        connectorId?: string | null;
+    }[] | null;
+    /** Number of ICMP Address Mask Reply messages received */
+    snmpIcmpInAddrMaskReps?: number | null;
+    /** Number of ICMP Address Mask Request messages received */
+    snmpIcmpInAddrMasks?: number | null;
+    /** Number of ICMP messages received with bad checksums */
+    snmpIcmpInCsumErrors?: number | null;
+    /** Number of ICMP Destination Unreachable messages received */
+    snmpIcmpInDestUnreachs?: number | null;
+    /** Number of ICMP Echo Reply messages received */
+    snmpIcmpInEchoReps?: number | null;
+    /** Number of ICMP Echo (request) messages received */
+    snmpIcmpInEchos?: number | null;
+    /** Number of ICMP messages received with ICMP-specific errors */
+    snmpIcmpInErrors?: number | null;
+    /** Number of ICMP messages received */
+    snmpIcmpInMsgs?: number | null;
+    /** Number of ICMP Parameter Problem messages received */
+    snmpIcmpInParmProbs?: number | null;
+    /** Number of ICMP Redirect messages received */
+    snmpIcmpInRedirects?: number | null;
+    /** Number of ICMP Source Quench messages received */
+    snmpIcmpInSrcQuenchs?: number | null;
+    /** Number of ICMP Time Exceeded messages received */
+    snmpIcmpInTimeExcds?: number | null;
+    /** Number of ICMP Address Mask Request messages received */
+    snmpIcmpInTimestampReps?: number | null;
+    /** Number of ICMP Timestamp (request) messages received */
+    snmpIcmpInTimestamps?: number | null;
+    /** Number of ICMP Address Mask Reply messages sent */
+    snmpIcmpOutAddrMaskReps?: number | null;
+    /** Number of ICMP Address Mask Request messages sent */
+    snmpIcmpOutAddrMasks?: number | null;
+    /** Number of ICMP Destination Unreachable messages sent */
+    snmpIcmpOutDestUnreachs?: number | null;
+    /** Number of ICMP Echo Reply messages sent */
+    snmpIcmpOutEchoReps?: number | null;
+    /** Number of ICMP Echo (request) messages sent */
+    snmpIcmpOutEchos?: number | null;
+    /** Number of ICMP messages which this entity did not send due to ICMP-specific errors */
+    snmpIcmpOutErrors?: number | null;
+    /** Number of ICMP messages attempted to send */
+    snmpIcmpOutMsgs?: number | null;
+    /** Number of ICMP Parameter Problem messages sent */
+    snmpIcmpOutParmProbs?: number | null;
+    /** Number of ICMP Redirect messages sent */
+    snmpIcmpOutRedirects?: number | null;
+    /** Number of ICMP Source Quench messages sent */
+    snmpIcmpOutSrcQuenchs?: number | null;
+    /** Number of ICMP Time Exceeded messages sent */
+    snmpIcmpOutTimeExcds?: number | null;
+    /** Number of ICMP Timestamp Reply messages sent */
+    snmpIcmpOutTimestampReps?: number | null;
+    /** Number of ICMP Timestamp (request) messages sent */
+    snmpIcmpOutTimestamps?: number | null;
+    /** Default value of the Time-To-Live field of the IP header */
+    snmpIpDefaultTtl?: number | null;
+    /** Number of datagrams forwarded to their final destination */
+    snmpIpForwDatagrams?: number | null;
+    /** Set when acting as an IP gateway */
+    snmpIpForwardingEnabled?: boolean | null;
+    /** Number of datagrams generated by fragmentation */
+    snmpIpFragCreates?: number | null;
+    /** Number of datagrams discarded because fragmentation failed */
+    snmpIpFragFails?: number | null;
+    /** Number of datagrams successfully fragmented */
+    snmpIpFragOks?: number | null;
+    /** Number of input datagrams discarded due to errors in the IP address */
+    snmpIpInAddrErrors?: number | null;
+    /** Number of input datagrams successfully delivered to IP user-protocols */
+    snmpIpInDelivers?: number | null;
+    /** Number of input datagrams otherwise discarded */
+    snmpIpInDiscards?: number | null;
+    /** Number of input datagrams discarded due to errors in the IP header */
+    snmpIpInHdrErrors?: number | null;
+    /** Number of input datagrams received from interfaces */
+    snmpIpInReceives?: number | null;
+    /** Number of input datagrams discarded due unknown or unsupported protocol */
+    snmpIpInUnknownProtos?: number | null;
+    /** Number of output datagrams otherwise discarded */
+    snmpIpOutDiscards?: number | null;
+    /** Number of output datagrams discarded because no route matched */
+    snmpIpOutNoRoutes?: number | null;
+    /** Number of datagrams supplied for transmission */
+    snmpIpOutRequests?: number | null;
+    /** Number of failures detected by the reassembly algorithm */
+    snmpIpReasmFails?: number | null;
+    /** Number of datagrams successfully reassembled */
+    snmpIpReasmOks?: number | null;
+    /** Number of fragments received which needed to be reassembled */
+    snmpIpReasmReqds?: number | null;
+    /** Number of seconds fragments are held while awaiting reassembly */
+    snmpIpReasmTimeout?: number | null;
+    /** Number of times TCP transitions to SYN-SENT from CLOSED */
+    snmpTcpActiveOpens?: number | null;
+    /** Number of times TCP transitions to CLOSED from SYN-SENT or SYN-RCVD, plus transitions to LISTEN from SYN-RCVD */
+    snmpTcpAttemptFails?: number | null;
+    /** Number of TCP connections in ESTABLISHED or CLOSE-WAIT */
+    snmpTcpCurrEstab?: number | null;
+    /** Number of times TCP transitions to CLOSED from ESTABLISHED or CLOSE-WAIT */
+    snmpTcpEstabResets?: number | null;
+    /** Number of TCP segments received with checksum errors */
+    snmpTcpInCsumErrors?: number | null;
+    /** Number of TCP segments received in error */
+    snmpTcpInErrs?: number | null;
+    /** Number of TCP segments received */
+    snmpTcpInSegs?: number | null;
+    /** Limit on the total number of TCP connections */
+    snmpTcpMaxConn?: number | null;
+    /** Number of TCP segments sent with RST flag */
+    snmpTcpOutRsts?: number | null;
+    /** Number of TCP segments sent */
+    snmpTcpOutSegs?: number | null;
+    /** Number of times TCP transitions to SYN-RCVD from LISTEN */
+    snmpTcpPassiveOpens?: number | null;
+    /** Number of TCP segments retransmitted */
+    snmpTcpRetransSegs?: number | null;
+    /** Maximum value permitted by a TCP implementation for the retransmission timeout (milliseconds) */
+    snmpTcpRtoMax?: number | null;
+    /** Minimum value permitted by a TCP implementation for the retransmission timeout (milliseconds) */
+    snmpTcpRtoMin?: number | null;
+    /** Number of UDP datagrams delivered to UDP applications */
+    snmpUdpInDatagrams?: number | null;
+    /** Number of UDP datagrams failed to be delivered for reasons other than lack of application at the destination port */
+    snmpUdpInErrors?: number | null;
+    /** Number of UDP datagrams received for which there was not application at the destination port */
+    snmpUdpNoPorts?: number | null;
+    /** Number of UDP datagrams sent */
+    snmpUdpOutDatagrams?: number | null;
+    /** Boottime of the system (seconds since the Unix epoch) */
+    systemBootTimeS?: number | null;
+    thermals?: {
+        label: string;
+        connectorId?: string | null;
+        criticalCelcius?: number | null;
+        currentCelcius?: number | null;
+        maxCelcius?: number | null;
+    }[] | null;
+    tunnels?: {
+        healthState: string;
+        healthValue: number;
+        interfaceName: string;
+        tunnelId: string;
+        connectorId?: string | null;
+        probedMtu?: number | null;
+    }[] | null;
+    /** Sum of how much time each core has spent idle */
+    uptimeIdleMs?: number | null;
+    /** Uptime of the system, including time spent in suspend */
+    uptimeTotalMs?: number | null;
+}
+export declare const GetConnectorSnapshotResponse: Schema.Schema<GetConnectorSnapshotResponse>;
+export type GetConnectorSnapshotError = DefaultErrors;
+export declare const getConnectorSnapshot: API.OperationMethod<GetConnectorSnapshotRequest, GetConnectorSnapshotResponse, GetConnectorSnapshotError, Credentials | HttpClient.HttpClient>;
+export interface ListConnectorSnapshotsRequest {
+    connectorId: string;
+    /** Path param: Account identifier */
+    accountId: string;
+    /** Query param: */
+    from: number;
+    /** Query param: */
+    to: number;
+    /** Query param: */
+    cursor?: string;
+    /** Query param: */
+    limit?: number;
+}
+export declare const ListConnectorSnapshotsRequest: Schema.Schema<ListConnectorSnapshotsRequest>;
+export interface ListConnectorSnapshotsResponse {
+    count: number;
+    items: {
+        a: number;
+        t: number;
+    }[];
+    cursor?: string | null;
+}
+export declare const ListConnectorSnapshotsResponse: Schema.Schema<ListConnectorSnapshotsResponse>;
+export type ListConnectorSnapshotsError = DefaultErrors;
+export declare const listConnectorSnapshots: API.OperationMethod<ListConnectorSnapshotsRequest, ListConnectorSnapshotsResponse, ListConnectorSnapshotsError, Credentials | HttpClient.HttpClient>;
+export interface ListConnectorSnapshotLatestsRequest {
+    connectorId: string;
+    /** Account identifier */
+    accountId: string;
+}
+export declare const ListConnectorSnapshotLatestsRequest: Schema.Schema<ListConnectorSnapshotLatestsRequest>;
+export interface ListConnectorSnapshotLatestsResponse {
+    count: number;
+    items: {
+        countReclaimFailures: number;
+        countReclaimedPaths: number;
+        countRecordFailed: number;
+        countTransmitFailures: number;
+        t: number;
+        v: string;
+        bonds?: {
+            name: string;
+            status: string;
+        }[] | null;
+        cpuCount?: number | null;
+        cpuPressure_10s?: number | null;
+        cpuPressure_300s?: number | null;
+        cpuPressure_60s?: number | null;
+        cpuPressureTotalUs?: number | null;
+        cpuTimeGuestMs?: number | null;
+        cpuTimeGuestNiceMs?: number | null;
+        cpuTimeIdleMs?: number | null;
+        cpuTimeIowaitMs?: number | null;
+        cpuTimeIrqMs?: number | null;
+        cpuTimeNiceMs?: number | null;
+        cpuTimeSoftirqMs?: number | null;
+        cpuTimeStealMs?: number | null;
+        cpuTimeSystemMs?: number | null;
+        cpuTimeUserMs?: number | null;
+        dhcpLeases?: {
+            clientId: string;
+            expiryTime: number;
+            hostname: string;
+            interfaceName: string;
+            ipAddress: string;
+            macAddress: string;
+            connectorId?: string | null;
+        }[] | null;
+        disks?: {
+            inProgress: number;
+            major: number;
+            merged: number;
+            minor: number;
+            name: string;
+            reads: number;
+            sectorsRead: number;
+            sectorsWritten: number;
+            timeInProgressMs: number;
+            timeReadingMs: number;
+            timeWritingMs: number;
+            weightedTimeInProgressMs: number;
+            writes: number;
+            writesMerged: number;
+            connectorId?: string | null;
+            discards?: number | null;
+            discardsMerged?: number | null;
+            flushes?: number | null;
+            sectorsDiscarded?: number | null;
+            timeDiscardingMs?: number | null;
+            timeFlushingMs?: number | null;
+        }[] | null;
+        haState?: string | null;
+        haValue?: number | null;
+        interfaces?: {
+            name: string;
+            operstate: string;
+            connectorId?: string | null;
+            ipAddresses?: {
+                interfaceName: string;
+                ipAddress: string;
+                connectorId?: string | null;
+            }[] | null;
+            speed?: number | null;
+        }[] | null;
+        ioPressureFull_10s?: number | null;
+        ioPressureFull_300s?: number | null;
+        ioPressureFull_60s?: number | null;
+        ioPressureFullTotalUs?: number | null;
+        ioPressureSome_10s?: number | null;
+        ioPressureSome_300s?: number | null;
+        ioPressureSome_60s?: number | null;
+        ioPressureSomeTotalUs?: number | null;
+        kernelBtime?: number | null;
+        kernelCtxt?: number | null;
+        kernelProcesses?: number | null;
+        kernelProcessesBlocked?: number | null;
+        kernelProcessesRunning?: number | null;
+        loadAverage_15m?: number | null;
+        loadAverage_1m?: number | null;
+        loadAverage_5m?: number | null;
+        loadAverageCur?: number | null;
+        loadAverageMax?: number | null;
+        memoryActiveBytes?: number | null;
+        memoryAnonHugepagesBytes?: number | null;
+        memoryAnonPagesBytes?: number | null;
+        memoryAvailableBytes?: number | null;
+        memoryBounceBytes?: number | null;
+        memoryBuffersBytes?: number | null;
+        memoryCachedBytes?: number | null;
+        memoryCmaFreeBytes?: number | null;
+        memoryCmaTotalBytes?: number | null;
+        memoryCommitLimitBytes?: number | null;
+        memoryCommittedAsBytes?: number | null;
+        memoryDirtyBytes?: number | null;
+        memoryFreeBytes?: number | null;
+        memoryHighFreeBytes?: number | null;
+        memoryHighTotalBytes?: number | null;
+        memoryHugepagesFree?: number | null;
+        memoryHugepagesRsvd?: number | null;
+        memoryHugepagesSurp?: number | null;
+        memoryHugepagesTotal?: number | null;
+        memoryHugepagesizeBytes?: number | null;
+        memoryInactiveBytes?: number | null;
+        memoryKReclaimableBytes?: number | null;
+        memoryKernelStackBytes?: number | null;
+        memoryLowFreeBytes?: number | null;
+        memoryLowTotalBytes?: number | null;
+        memoryMappedBytes?: number | null;
+        memoryPageTablesBytes?: number | null;
+        memoryPerCpuBytes?: number | null;
+        memoryPressureFull_10s?: number | null;
+        memoryPressureFull_300s?: number | null;
+        memoryPressureFull_60s?: number | null;
+        memoryPressureFullTotalUs?: number | null;
+        memoryPressureSome_10s?: number | null;
+        memoryPressureSome_300s?: number | null;
+        memoryPressureSome_60s?: number | null;
+        memoryPressureSomeTotalUs?: number | null;
+        memorySReclaimableBytes?: number | null;
+        memorySUnreclaimBytes?: number | null;
+        memorySecondaryPageTablesBytes?: number | null;
+        memoryShmemBytes?: number | null;
+        memoryShmemHugepagesBytes?: number | null;
+        memoryShmemPmdMappedBytes?: number | null;
+        memorySlabBytes?: number | null;
+        memorySwapCachedBytes?: number | null;
+        memorySwapFreeBytes?: number | null;
+        memorySwapTotalBytes?: number | null;
+        memoryTotalBytes?: number | null;
+        memoryVmallocChunkBytes?: number | null;
+        memoryVmallocTotalBytes?: number | null;
+        memoryVmallocUsedBytes?: number | null;
+        memoryWritebackBytes?: number | null;
+        memoryWritebackTmpBytes?: number | null;
+        memoryZSwapBytes?: number | null;
+        memoryZSwappedBytes?: number | null;
+        mounts?: {
+            fileSystem: string;
+            kind: string;
+            mountPoint: string;
+            name: string;
+            availableBytes?: number | null;
+            connectorId?: string | null;
+            isReadOnly?: boolean | null;
+            isRemovable?: boolean | null;
+            totalBytes?: number | null;
+        }[] | null;
+        netdevs?: {
+            name: string;
+            recvBytes: number;
+            recvCompressed: number;
+            recvDrop: number;
+            recvErrs: number;
+            recvFifo: number;
+            recvFrame: number;
+            recvMulticast: number;
+            recvPackets: number;
+            sentBytes: number;
+            sentCarrier: number;
+            sentColls: number;
+            sentCompressed: number;
+            sentDrop: number;
+            sentErrs: number;
+            sentFifo: number;
+            sentPackets: number;
+            connectorId?: string | null;
+        }[] | null;
+        snmpIcmpInAddrMaskReps?: number | null;
+        snmpIcmpInAddrMasks?: number | null;
+        snmpIcmpInCsumErrors?: number | null;
+        snmpIcmpInDestUnreachs?: number | null;
+        snmpIcmpInEchoReps?: number | null;
+        snmpIcmpInEchos?: number | null;
+        snmpIcmpInErrors?: number | null;
+        snmpIcmpInMsgs?: number | null;
+        snmpIcmpInParmProbs?: number | null;
+        snmpIcmpInRedirects?: number | null;
+        snmpIcmpInSrcQuenchs?: number | null;
+        snmpIcmpInTimeExcds?: number | null;
+        snmpIcmpInTimestampReps?: number | null;
+        snmpIcmpInTimestamps?: number | null;
+        snmpIcmpOutAddrMaskReps?: number | null;
+        snmpIcmpOutAddrMasks?: number | null;
+        snmpIcmpOutDestUnreachs?: number | null;
+        snmpIcmpOutEchoReps?: number | null;
+        snmpIcmpOutEchos?: number | null;
+        snmpIcmpOutErrors?: number | null;
+        snmpIcmpOutMsgs?: number | null;
+        snmpIcmpOutParmProbs?: number | null;
+        snmpIcmpOutRedirects?: number | null;
+        snmpIcmpOutSrcQuenchs?: number | null;
+        snmpIcmpOutTimeExcds?: number | null;
+        snmpIcmpOutTimestampReps?: number | null;
+        snmpIcmpOutTimestamps?: number | null;
+        snmpIpDefaultTtl?: number | null;
+        snmpIpForwDatagrams?: number | null;
+        snmpIpForwardingEnabled?: boolean | null;
+        snmpIpFragCreates?: number | null;
+        snmpIpFragFails?: number | null;
+        snmpIpFragOks?: number | null;
+        snmpIpInAddrErrors?: number | null;
+        snmpIpInDelivers?: number | null;
+        snmpIpInDiscards?: number | null;
+        snmpIpInHdrErrors?: number | null;
+        snmpIpInReceives?: number | null;
+        snmpIpInUnknownProtos?: number | null;
+        snmpIpOutDiscards?: number | null;
+        snmpIpOutNoRoutes?: number | null;
+        snmpIpOutRequests?: number | null;
+        snmpIpReasmFails?: number | null;
+        snmpIpReasmOks?: number | null;
+        snmpIpReasmReqds?: number | null;
+        snmpIpReasmTimeout?: number | null;
+        snmpTcpActiveOpens?: number | null;
+        snmpTcpAttemptFails?: number | null;
+        snmpTcpCurrEstab?: number | null;
+        snmpTcpEstabResets?: number | null;
+        snmpTcpInCsumErrors?: number | null;
+        snmpTcpInErrs?: number | null;
+        snmpTcpInSegs?: number | null;
+        snmpTcpMaxConn?: number | null;
+        snmpTcpOutRsts?: number | null;
+        snmpTcpOutSegs?: number | null;
+        snmpTcpPassiveOpens?: number | null;
+        snmpTcpRetransSegs?: number | null;
+        snmpTcpRtoMax?: number | null;
+        snmpTcpRtoMin?: number | null;
+        snmpUdpInDatagrams?: number | null;
+        snmpUdpInErrors?: number | null;
+        snmpUdpNoPorts?: number | null;
+        snmpUdpOutDatagrams?: number | null;
+        systemBootTimeS?: number | null;
+        thermals?: {
+            label: string;
+            connectorId?: string | null;
+            criticalCelcius?: number | null;
+            currentCelcius?: number | null;
+            maxCelcius?: number | null;
+        }[] | null;
+        tunnels?: {
+            healthState: string;
+            healthValue: number;
+            interfaceName: string;
+            tunnelId: string;
+            connectorId?: string | null;
+            probedMtu?: number | null;
+        }[] | null;
+        uptimeIdleMs?: number | null;
+        uptimeTotalMs?: number | null;
+    }[];
+}
+export declare const ListConnectorSnapshotLatestsResponse: Schema.Schema<ListConnectorSnapshotLatestsResponse>;
+export type ListConnectorSnapshotLatestsError = DefaultErrors;
+export declare const listConnectorSnapshotLatests: API.OperationMethod<ListConnectorSnapshotLatestsRequest, ListConnectorSnapshotLatestsResponse, ListConnectorSnapshotLatestsError, Credentials | HttpClient.HttpClient>;
+export interface PskGenerateIpsecTunnelRequest {
+    ipsecTunnelId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Body param: */
+    body: unknown;
+}
+export declare const PskGenerateIpsecTunnelRequest: Schema.Schema<PskGenerateIpsecTunnelRequest>;
+export interface PskGenerateIpsecTunnelResponse {
+    /** Identifier */
+    ipsecTunnelId?: string | null;
+    /** A randomly generated or provided string for use in the IPsec tunnel. */
+    psk?: string | null;
+    /** The PSK metadata that includes when the PSK was generated. */
+    pskMetadata?: {
+        lastGeneratedOn?: string | null;
+    } | null;
+}
+export declare const PskGenerateIpsecTunnelResponse: Schema.Schema<PskGenerateIpsecTunnelResponse>;
+export type PskGenerateIpsecTunnelError = DefaultErrors;
+export declare const pskGenerateIpsecTunnel: API.OperationMethod<PskGenerateIpsecTunnelRequest, PskGenerateIpsecTunnelResponse, PskGenerateIpsecTunnelError, Credentials | HttpClient.HttpClient>;
+export interface GetGreTunnelRequest {
+    greTunnelId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Header param: If true, the health check target in the response body will be presented using the new object format. Defaults to false. */
+    xMagicNewHcTarget?: boolean;
+}
+export declare const GetGreTunnelRequest: Schema.Schema<GetGreTunnelRequest>;
+export interface GetGreTunnelResponse {
+    greTunnel?: {
+        id: string;
+        cloudflareGreEndpoint: string;
+        customerGreEndpoint: string;
+        interfaceAddress: string;
+        name: string;
+        automaticReturnRouting?: boolean | null;
+        bgp?: {
+            customerAsn: number;
+            extraPrefixes?: string[] | null;
+            md5Key?: string | null;
+        } | null;
+        bgpStatus?: {
+            state: "BGP_DOWN" | "BGP_UP" | "BGP_ESTABLISHING";
+            tcpEstablished: boolean;
+            updatedAt: string;
+            bgpState?: string | null;
+            cfSpeakerIp?: string | null;
+            cfSpeakerPort?: number | null;
+            customerSpeakerIp?: string | null;
+            customerSpeakerPort?: number | null;
+        } | null;
+        createdOn?: string | null;
+        description?: string | null;
+        healthCheck?: {
+            direction?: "unidirectional" | "bidirectional" | null;
+            enabled?: boolean | null;
+            rate?: "low" | "mid" | "high" | null;
+            target?: {
+                saved?: string | null;
+            } | string | null;
+            type?: "reply" | "request" | null;
+        } | null;
+        interfaceAddress6?: string | null;
+        modifiedOn?: string | null;
+        mtu?: number | null;
+        ttl?: number | null;
+    } | null;
+}
+export declare const GetGreTunnelResponse: Schema.Schema<GetGreTunnelResponse>;
+export type GetGreTunnelError = DefaultErrors;
+export declare const getGreTunnel: API.OperationMethod<GetGreTunnelRequest, GetGreTunnelResponse, GetGreTunnelError, Credentials | HttpClient.HttpClient>;
+export interface ListGreTunnelsRequest {
+    /** Path param: Identifier */
+    accountId: string;
+    /** Header param: If true, the health check target in the response body will be presented using the new object format. Defaults to false. */
+    xMagicNewHcTarget?: boolean;
+}
+export declare const ListGreTunnelsRequest: Schema.Schema<ListGreTunnelsRequest>;
+export interface ListGreTunnelsResponse {
+    greTunnels?: {
+        id: string;
+        cloudflareGreEndpoint: string;
+        customerGreEndpoint: string;
+        interfaceAddress: string;
+        name: string;
+        automaticReturnRouting?: boolean | null;
+        bgp?: {
+            customerAsn: number;
+            extraPrefixes?: string[] | null;
+            md5Key?: string | null;
+        } | null;
+        bgpStatus?: {
+            state: "BGP_DOWN" | "BGP_UP" | "BGP_ESTABLISHING";
+            tcpEstablished: boolean;
+            updatedAt: string;
+            bgpState?: string | null;
+            cfSpeakerIp?: string | null;
+            cfSpeakerPort?: number | null;
+            customerSpeakerIp?: string | null;
+            customerSpeakerPort?: number | null;
+        } | null;
+        createdOn?: string | null;
+        description?: string | null;
+        healthCheck?: {
+            direction?: "unidirectional" | "bidirectional" | null;
+            enabled?: boolean | null;
+            rate?: "low" | "mid" | "high" | null;
+            target?: {
+                saved?: string | null;
+            } | string | null;
+            type?: "reply" | "request" | null;
+        } | null;
+        interfaceAddress6?: string | null;
+        modifiedOn?: string | null;
+        mtu?: number | null;
+        ttl?: number | null;
+    }[] | null;
+}
+export declare const ListGreTunnelsResponse: Schema.Schema<ListGreTunnelsResponse>;
+export type ListGreTunnelsError = DefaultErrors;
+export declare const listGreTunnels: API.OperationMethod<ListGreTunnelsRequest, ListGreTunnelsResponse, ListGreTunnelsError, Credentials | HttpClient.HttpClient>;
+export interface CreateGreTunnelRequest {
+    /** Path param: Identifier */
+    accountId: string;
+    /** Header param: If true, the health check target in the request and response bodies will be presented using the new object format. Defaults to false. */
+    xMagicNewHcTarget?: boolean;
+    /** Body param: The IP address assigned to the Cloudflare side of the GRE tunnel. */
+    cloudflareGreEndpoint: string;
+    /** Body param: The IP address assigned to the customer side of the GRE tunnel. */
+    customerGreEndpoint: string;
+    /** Body param: A 31-bit prefix (/31 in CIDR notation) supporting two hosts, one for each side of the tunnel. Select the subnet from the following private IP space: 10.0.0.0–10.255.255.255, 172.16.0.0–172 */
+    interfaceAddress: string;
+    /** Body param: The name of the tunnel. The name cannot contain spaces or special characters, must be 15 characters or less, and cannot share a name with another GRE tunnel. */
+    name: string;
+    /** Body param: True if automatic stateful return routing should be enabled for a tunnel, false otherwise. */
+    automaticReturnRouting?: boolean;
+    /** Body param: */
+    bgp?: {
+        customerAsn: number;
+        extraPrefixes?: string[];
+        md5Key?: string;
+    };
+    /** Body param: An optional description of the GRE tunnel. */
+    description?: string;
+    /** Body param: */
+    healthCheck?: {
+        direction?: "unidirectional" | "bidirectional";
+        enabled?: boolean;
+        rate?: "low" | "mid" | "high";
+        target?: {
+            saved?: string;
+        } | string;
+        type?: "reply" | "request";
+    };
+    /** Body param: A 127 bit IPV6 prefix from within the virtual_subnet6 prefix space with the address being the first IP of the subnet and not same as the address of virtual_subnet6. Eg if virtual_subnet6 i */
+    interfaceAddress6?: string;
+    /** Body param: Maximum Transmission Unit (MTU) in bytes for the GRE tunnel. The minimum value is 576. */
+    mtu?: number;
+    /** Body param: Time To Live (TTL) in number of hops of the GRE tunnel. */
+    ttl?: number;
+}
+export declare const CreateGreTunnelRequest: Schema.Schema<CreateGreTunnelRequest>;
+export interface CreateGreTunnelResponse {
+    /** Identifier */
+    id: string;
+    /** The IP address assigned to the Cloudflare side of the GRE tunnel. */
+    cloudflareGreEndpoint: string;
+    /** The IP address assigned to the customer side of the GRE tunnel. */
+    customerGreEndpoint: string;
+    /** A 31-bit prefix (/31 in CIDR notation) supporting two hosts, one for each side of the tunnel. Select the subnet from the following private IP space: 10.0.0.0–10.255.255.255, 172.16.0.0–172.31.255.255, */
+    interfaceAddress: string;
+    /** The name of the tunnel. The name cannot contain spaces or special characters, must be 15 characters or less, and cannot share a name with another GRE tunnel. */
+    name: string;
+    /** True if automatic stateful return routing should be enabled for a tunnel, false otherwise. */
+    automaticReturnRouting?: boolean | null;
+    bgp?: {
+        customerAsn: number;
+        extraPrefixes?: string[] | null;
+        md5Key?: string | null;
+    } | null;
+    bgpStatus?: {
+        state: "BGP_DOWN" | "BGP_UP" | "BGP_ESTABLISHING";
+        tcpEstablished: boolean;
+        updatedAt: string;
+        bgpState?: string | null;
+        cfSpeakerIp?: string | null;
+        cfSpeakerPort?: number | null;
+        customerSpeakerIp?: string | null;
+        customerSpeakerPort?: number | null;
+    } | null;
+    /** The date and time the tunnel was created. */
+    createdOn?: string | null;
+    /** An optional description of the GRE tunnel. */
+    description?: string | null;
+    healthCheck?: {
+        direction?: "unidirectional" | "bidirectional" | null;
+        enabled?: boolean | null;
+        rate?: "low" | "mid" | "high" | null;
+        target?: {
+            saved?: string | null;
+        } | string | null;
+        type?: "reply" | "request" | null;
+    } | null;
+    /** A 127 bit IPV6 prefix from within the virtual_subnet6 prefix space with the address being the first IP of the subnet and not same as the address of virtual_subnet6. Eg if virtual_subnet6 is 2606:54c1: */
+    interfaceAddress6?: string | null;
+    /** The date and time the tunnel was last modified. */
+    modifiedOn?: string | null;
+    /** Maximum Transmission Unit (MTU) in bytes for the GRE tunnel. The minimum value is 576. */
+    mtu?: number | null;
+    /** Time To Live (TTL) in number of hops of the GRE tunnel. */
+    ttl?: number | null;
+}
+export declare const CreateGreTunnelResponse: Schema.Schema<CreateGreTunnelResponse>;
+export type CreateGreTunnelError = DefaultErrors;
+export declare const createGreTunnel: API.OperationMethod<CreateGreTunnelRequest, CreateGreTunnelResponse, CreateGreTunnelError, Credentials | HttpClient.HttpClient>;
+export interface UpdateGreTunnelRequest {
+    greTunnelId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Header param: If true, the health check target in the request and response bodies will be presented using the new object format. Defaults to false. */
+    xMagicNewHcTarget?: boolean;
+    /** Body param: The IP address assigned to the Cloudflare side of the GRE tunnel. */
+    cloudflareGreEndpoint: string;
+    /** Body param: The IP address assigned to the customer side of the GRE tunnel. */
+    customerGreEndpoint: string;
+    /** Body param: A 31-bit prefix (/31 in CIDR notation) supporting two hosts, one for each side of the tunnel. Select the subnet from the following private IP space: 10.0.0.0–10.255.255.255, 172.16.0.0–172 */
+    interfaceAddress: string;
+    /** Body param: The name of the tunnel. The name cannot contain spaces or special characters, must be 15 characters or less, and cannot share a name with another GRE tunnel. */
+    name: string;
+    /** Body param: True if automatic stateful return routing should be enabled for a tunnel, false otherwise. */
+    automaticReturnRouting?: boolean;
+    /** Body param: An optional description of the GRE tunnel. */
+    description?: string;
+    /** Body param: */
+    healthCheck?: {
+        direction?: "unidirectional" | "bidirectional";
+        enabled?: boolean;
+        rate?: "low" | "mid" | "high";
+        target?: {
+            saved?: string;
+        } | string;
+        type?: "reply" | "request";
+    };
+    /** Body param: A 127 bit IPV6 prefix from within the virtual_subnet6 prefix space with the address being the first IP of the subnet and not same as the address of virtual_subnet6. Eg if virtual_subnet6 i */
+    interfaceAddress6?: string;
+    /** Body param: Maximum Transmission Unit (MTU) in bytes for the GRE tunnel. The minimum value is 576. */
+    mtu?: number;
+    /** Body param: Time To Live (TTL) in number of hops of the GRE tunnel. */
+    ttl?: number;
+}
+export declare const UpdateGreTunnelRequest: Schema.Schema<UpdateGreTunnelRequest>;
+export interface UpdateGreTunnelResponse {
+    modified?: boolean | null;
+    modifiedGreTunnel?: {
+        id: string;
+        cloudflareGreEndpoint: string;
+        customerGreEndpoint: string;
+        interfaceAddress: string;
+        name: string;
+        automaticReturnRouting?: boolean | null;
+        bgp?: {
+            customerAsn: number;
+            extraPrefixes?: string[] | null;
+            md5Key?: string | null;
+        } | null;
+        bgpStatus?: {
+            state: "BGP_DOWN" | "BGP_UP" | "BGP_ESTABLISHING";
+            tcpEstablished: boolean;
+            updatedAt: string;
+            bgpState?: string | null;
+            cfSpeakerIp?: string | null;
+            cfSpeakerPort?: number | null;
+            customerSpeakerIp?: string | null;
+            customerSpeakerPort?: number | null;
+        } | null;
+        createdOn?: string | null;
+        description?: string | null;
+        healthCheck?: {
+            direction?: "unidirectional" | "bidirectional" | null;
+            enabled?: boolean | null;
+            rate?: "low" | "mid" | "high" | null;
+            target?: {
+                saved?: string | null;
+            } | string | null;
+            type?: "reply" | "request" | null;
+        } | null;
+        interfaceAddress6?: string | null;
+        modifiedOn?: string | null;
+        mtu?: number | null;
+        ttl?: number | null;
+    } | null;
+}
+export declare const UpdateGreTunnelResponse: Schema.Schema<UpdateGreTunnelResponse>;
+export type UpdateGreTunnelError = DefaultErrors;
+export declare const updateGreTunnel: API.OperationMethod<UpdateGreTunnelRequest, UpdateGreTunnelResponse, UpdateGreTunnelError, Credentials | HttpClient.HttpClient>;
+export interface DeleteGreTunnelRequest {
+    greTunnelId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Header param: If true, the health check target in the response body will be presented using the new object format. Defaults to false. */
+    xMagicNewHcTarget?: boolean;
+}
+export declare const DeleteGreTunnelRequest: Schema.Schema<DeleteGreTunnelRequest>;
+export interface DeleteGreTunnelResponse {
+    deleted?: boolean | null;
+    deletedGreTunnel?: {
+        id: string;
+        cloudflareGreEndpoint: string;
+        customerGreEndpoint: string;
+        interfaceAddress: string;
+        name: string;
+        automaticReturnRouting?: boolean | null;
+        bgp?: {
+            customerAsn: number;
+            extraPrefixes?: string[] | null;
+            md5Key?: string | null;
+        } | null;
+        bgpStatus?: {
+            state: "BGP_DOWN" | "BGP_UP" | "BGP_ESTABLISHING";
+            tcpEstablished: boolean;
+            updatedAt: string;
+            bgpState?: string | null;
+            cfSpeakerIp?: string | null;
+            cfSpeakerPort?: number | null;
+            customerSpeakerIp?: string | null;
+            customerSpeakerPort?: number | null;
+        } | null;
+        createdOn?: string | null;
+        description?: string | null;
+        healthCheck?: {
+            direction?: "unidirectional" | "bidirectional" | null;
+            enabled?: boolean | null;
+            rate?: "low" | "mid" | "high" | null;
+            target?: {
+                saved?: string | null;
+            } | string | null;
+            type?: "reply" | "request" | null;
+        } | null;
+        interfaceAddress6?: string | null;
+        modifiedOn?: string | null;
+        mtu?: number | null;
+        ttl?: number | null;
+    } | null;
+}
+export declare const DeleteGreTunnelResponse: Schema.Schema<DeleteGreTunnelResponse>;
+export type DeleteGreTunnelError = DefaultErrors;
+export declare const deleteGreTunnel: API.OperationMethod<DeleteGreTunnelRequest, DeleteGreTunnelResponse, DeleteGreTunnelError, Credentials | HttpClient.HttpClient>;
+export interface GetIpsecTunnelRequest {
+    ipsecTunnelId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Header param: If true, the health check target in the response body will be presented using the new object format. Defaults to false. */
+    xMagicNewHcTarget?: boolean;
+}
+export declare const GetIpsecTunnelRequest: Schema.Schema<GetIpsecTunnelRequest>;
+export interface GetIpsecTunnelResponse {
+    ipsecTunnel?: {
+        id: string;
+        cloudflareEndpoint: string;
+        interfaceAddress: string;
+        name: string;
+        allowNullCipher?: boolean | null;
+        automaticReturnRouting?: boolean | null;
+        bgp?: {
+            customerAsn: number;
+            extraPrefixes?: string[] | null;
+            md5Key?: string | null;
+        } | null;
+        bgpStatus?: {
+            state: "BGP_DOWN" | "BGP_UP" | "BGP_ESTABLISHING";
+            tcpEstablished: boolean;
+            updatedAt: string;
+            bgpState?: string | null;
+            cfSpeakerIp?: string | null;
+            cfSpeakerPort?: number | null;
+            customerSpeakerIp?: string | null;
+            customerSpeakerPort?: number | null;
+        } | null;
+        createdOn?: string | null;
+        customRemoteIdentities?: {
+            fqdnId?: string | null;
+        } | null;
+        customerEndpoint?: string | null;
+        description?: string | null;
+        healthCheck?: {
+            direction?: "unidirectional" | "bidirectional" | null;
+            enabled?: boolean | null;
+            rate?: "low" | "mid" | "high" | null;
+            target?: {
+                saved?: string | null;
+            } | string | null;
+            type?: "reply" | "request" | null;
+        } | null;
+        interfaceAddress6?: string | null;
+        modifiedOn?: string | null;
+        pskMetadata?: unknown | null;
+        replayProtection?: boolean | null;
+    } | null;
+}
+export declare const GetIpsecTunnelResponse: Schema.Schema<GetIpsecTunnelResponse>;
+export type GetIpsecTunnelError = DefaultErrors;
+export declare const getIpsecTunnel: API.OperationMethod<GetIpsecTunnelRequest, GetIpsecTunnelResponse, GetIpsecTunnelError, Credentials | HttpClient.HttpClient>;
+export interface ListIpsecTunnelsRequest {
+    /** Path param: Identifier */
+    accountId: string;
+    /** Header param: If true, the health check target in the response body will be presented using the new object format. Defaults to false. */
+    xMagicNewHcTarget?: boolean;
+}
+export declare const ListIpsecTunnelsRequest: Schema.Schema<ListIpsecTunnelsRequest>;
+export interface ListIpsecTunnelsResponse {
+    ipsecTunnels?: {
+        id: string;
+        cloudflareEndpoint: string;
+        interfaceAddress: string;
+        name: string;
+        allowNullCipher?: boolean | null;
+        automaticReturnRouting?: boolean | null;
+        bgp?: {
+            customerAsn: number;
+            extraPrefixes?: string[] | null;
+            md5Key?: string | null;
+        } | null;
+        bgpStatus?: {
+            state: "BGP_DOWN" | "BGP_UP" | "BGP_ESTABLISHING";
+            tcpEstablished: boolean;
+            updatedAt: string;
+            bgpState?: string | null;
+            cfSpeakerIp?: string | null;
+            cfSpeakerPort?: number | null;
+            customerSpeakerIp?: string | null;
+            customerSpeakerPort?: number | null;
+        } | null;
+        createdOn?: string | null;
+        customRemoteIdentities?: {
+            fqdnId?: string | null;
+        } | null;
+        customerEndpoint?: string | null;
+        description?: string | null;
+        healthCheck?: {
+            direction?: "unidirectional" | "bidirectional" | null;
+            enabled?: boolean | null;
+            rate?: "low" | "mid" | "high" | null;
+            target?: {
+                saved?: string | null;
+            } | string | null;
+            type?: "reply" | "request" | null;
+        } | null;
+        interfaceAddress6?: string | null;
+        modifiedOn?: string | null;
+        pskMetadata?: unknown | null;
+        replayProtection?: boolean | null;
+    }[] | null;
+}
+export declare const ListIpsecTunnelsResponse: Schema.Schema<ListIpsecTunnelsResponse>;
+export type ListIpsecTunnelsError = DefaultErrors;
+export declare const listIpsecTunnels: API.OperationMethod<ListIpsecTunnelsRequest, ListIpsecTunnelsResponse, ListIpsecTunnelsError, Credentials | HttpClient.HttpClient>;
+export interface CreateIpsecTunnelRequest {
+    /** Path param: Identifier */
+    accountId: string;
+    /** Header param: If true, the health check target in the request and response bodies will be presented using the new object format. Defaults to false. */
+    xMagicNewHcTarget?: boolean;
+    /** Body param: The IP address assigned to the Cloudflare side of the IPsec tunnel. */
+    cloudflareEndpoint: string;
+    /** Body param: A 31-bit prefix (/31 in CIDR notation) supporting two hosts, one for each side of the tunnel. Select the subnet from the following private IP space: 10.0.0.0–10.255.255.255, 172.16.0.0–172 */
+    interfaceAddress: string;
+    /** Body param: The name of the IPsec tunnel. The name cannot share a name with other tunnels. */
+    name: string;
+    /** Body param: True if automatic stateful return routing should be enabled for a tunnel, false otherwise. */
+    automaticReturnRouting?: boolean;
+    /** Body param: */
+    bgp?: {
+        customerAsn: number;
+        extraPrefixes?: string[];
+        md5Key?: string;
+    };
+    /** Body param: */
+    customRemoteIdentities?: {
+        fqdnId?: string;
+    };
+    /** Body param: The IP address assigned to the customer side of the IPsec tunnel. Not required, but must be set for proactive traceroutes to work. */
+    customerEndpoint?: string;
+    /** Body param: An optional description forthe IPsec tunnel. */
+    description?: string;
+    /** Body param: */
+    healthCheck?: {
+        direction?: "unidirectional" | "bidirectional";
+        enabled?: boolean;
+        rate?: "low" | "mid" | "high";
+        target?: {
+            saved?: string;
+        } | string;
+        type?: "reply" | "request";
+    };
+    /** Body param: A 127 bit IPV6 prefix from within the virtual_subnet6 prefix space with the address being the first IP of the subnet and not same as the address of virtual_subnet6. Eg if virtual_subnet6 i */
+    interfaceAddress6?: string;
+    /** Body param: A randomly generated or provided string for use in the IPsec tunnel. */
+    psk?: string;
+    /** Body param: If `true`, then IPsec replay protection will be supported in the Cloudflare-to-customer direction. */
+    replayProtection?: boolean;
+}
+export declare const CreateIpsecTunnelRequest: Schema.Schema<CreateIpsecTunnelRequest>;
+export interface CreateIpsecTunnelResponse {
+    /** Identifier */
+    id: string;
+    /** The IP address assigned to the Cloudflare side of the IPsec tunnel. */
+    cloudflareEndpoint: string;
+    /** A 31-bit prefix (/31 in CIDR notation) supporting two hosts, one for each side of the tunnel. Select the subnet from the following private IP space: 10.0.0.0–10.255.255.255, 172.16.0.0–172.31.255.255, */
+    interfaceAddress: string;
+    /** The name of the IPsec tunnel. The name cannot share a name with other tunnels. */
+    name: string;
+    /** When `true`, the tunnel can use a null-cipher (`ENCR_NULL`) in the ESP tunnel (Phase 2). */
+    allowNullCipher?: boolean | null;
+    /** True if automatic stateful return routing should be enabled for a tunnel, false otherwise. */
+    automaticReturnRouting?: boolean | null;
+    bgp?: {
+        customerAsn: number;
+        extraPrefixes?: string[] | null;
+        md5Key?: string | null;
+    } | null;
+    bgpStatus?: {
+        state: "BGP_DOWN" | "BGP_UP" | "BGP_ESTABLISHING";
+        tcpEstablished: boolean;
+        updatedAt: string;
+        bgpState?: string | null;
+        cfSpeakerIp?: string | null;
+        cfSpeakerPort?: number | null;
+        customerSpeakerIp?: string | null;
+        customerSpeakerPort?: number | null;
+    } | null;
+    /** The date and time the tunnel was created. */
+    createdOn?: string | null;
+    customRemoteIdentities?: {
+        fqdnId?: string | null;
+    } | null;
+    /** The IP address assigned to the customer side of the IPsec tunnel. Not required, but must be set for proactive traceroutes to work. */
+    customerEndpoint?: string | null;
+    /** An optional description forthe IPsec tunnel. */
+    description?: string | null;
+    healthCheck?: {
+        direction?: "unidirectional" | "bidirectional" | null;
+        enabled?: boolean | null;
+        rate?: "low" | "mid" | "high" | null;
+        target?: {
+            saved?: string | null;
+        } | string | null;
+        type?: "reply" | "request" | null;
+    } | null;
+    /** A 127 bit IPV6 prefix from within the virtual_subnet6 prefix space with the address being the first IP of the subnet and not same as the address of virtual_subnet6. Eg if virtual_subnet6 is 2606:54c1: */
+    interfaceAddress6?: string | null;
+    /** The date and time the tunnel was last modified. */
+    modifiedOn?: string | null;
+    /** The PSK metadata that includes when the PSK was generated. */
+    pskMetadata?: {
+        lastGeneratedOn?: string | null;
+    } | null;
+    /** If `true`, then IPsec replay protection will be supported in the Cloudflare-to-customer direction. */
+    replayProtection?: boolean | null;
+}
+export declare const CreateIpsecTunnelResponse: Schema.Schema<CreateIpsecTunnelResponse>;
+export type CreateIpsecTunnelError = DefaultErrors;
+export declare const createIpsecTunnel: API.OperationMethod<CreateIpsecTunnelRequest, CreateIpsecTunnelResponse, CreateIpsecTunnelError, Credentials | HttpClient.HttpClient>;
+export interface UpdateIpsecTunnelRequest {
+    ipsecTunnelId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Header param: If true, the health check target in the request and response bodies will be presented using the new object format. Defaults to false. */
+    xMagicNewHcTarget?: boolean;
+    /** Body param: The IP address assigned to the Cloudflare side of the IPsec tunnel. */
+    cloudflareEndpoint: string;
+    /** Body param: A 31-bit prefix (/31 in CIDR notation) supporting two hosts, one for each side of the tunnel. Select the subnet from the following private IP space: 10.0.0.0–10.255.255.255, 172.16.0.0–172 */
+    interfaceAddress: string;
+    /** Body param: The name of the IPsec tunnel. The name cannot share a name with other tunnels. */
+    name: string;
+    /** Body param: True if automatic stateful return routing should be enabled for a tunnel, false otherwise. */
+    automaticReturnRouting?: boolean;
+    /** Body param: */
+    bgp?: {
+        customerAsn: number;
+        extraPrefixes?: string[];
+        md5Key?: string;
+    };
+    /** Body param: */
+    customRemoteIdentities?: {
+        fqdnId?: string;
+    };
+    /** Body param: The IP address assigned to the customer side of the IPsec tunnel. Not required, but must be set for proactive traceroutes to work. */
+    customerEndpoint?: string;
+    /** Body param: An optional description forthe IPsec tunnel. */
+    description?: string;
+    /** Body param: */
+    healthCheck?: {
+        direction?: "unidirectional" | "bidirectional";
+        enabled?: boolean;
+        rate?: "low" | "mid" | "high";
+        target?: {
+            saved?: string;
+        } | string;
+        type?: "reply" | "request";
+    };
+    /** Body param: A 127 bit IPV6 prefix from within the virtual_subnet6 prefix space with the address being the first IP of the subnet and not same as the address of virtual_subnet6. Eg if virtual_subnet6 i */
+    interfaceAddress6?: string;
+    /** Body param: A randomly generated or provided string for use in the IPsec tunnel. */
+    psk?: string;
+    /** Body param: If `true`, then IPsec replay protection will be supported in the Cloudflare-to-customer direction. */
+    replayProtection?: boolean;
+}
+export declare const UpdateIpsecTunnelRequest: Schema.Schema<UpdateIpsecTunnelRequest>;
+export interface UpdateIpsecTunnelResponse {
+    modified?: boolean | null;
+    modifiedIpsecTunnel?: {
+        id: string;
+        cloudflareEndpoint: string;
+        interfaceAddress: string;
+        name: string;
+        allowNullCipher?: boolean | null;
+        automaticReturnRouting?: boolean | null;
+        bgp?: {
+            customerAsn: number;
+            extraPrefixes?: string[] | null;
+            md5Key?: string | null;
+        } | null;
+        bgpStatus?: {
+            state: "BGP_DOWN" | "BGP_UP" | "BGP_ESTABLISHING";
+            tcpEstablished: boolean;
+            updatedAt: string;
+            bgpState?: string | null;
+            cfSpeakerIp?: string | null;
+            cfSpeakerPort?: number | null;
+            customerSpeakerIp?: string | null;
+            customerSpeakerPort?: number | null;
+        } | null;
+        createdOn?: string | null;
+        customRemoteIdentities?: {
+            fqdnId?: string | null;
+        } | null;
+        customerEndpoint?: string | null;
+        description?: string | null;
+        healthCheck?: {
+            direction?: "unidirectional" | "bidirectional" | null;
+            enabled?: boolean | null;
+            rate?: "low" | "mid" | "high" | null;
+            target?: {
+                saved?: string | null;
+            } | string | null;
+            type?: "reply" | "request" | null;
+        } | null;
+        interfaceAddress6?: string | null;
+        modifiedOn?: string | null;
+        pskMetadata?: unknown | null;
+        replayProtection?: boolean | null;
+    } | null;
+}
+export declare const UpdateIpsecTunnelResponse: Schema.Schema<UpdateIpsecTunnelResponse>;
+export type UpdateIpsecTunnelError = DefaultErrors;
+export declare const updateIpsecTunnel: API.OperationMethod<UpdateIpsecTunnelRequest, UpdateIpsecTunnelResponse, UpdateIpsecTunnelError, Credentials | HttpClient.HttpClient>;
+export interface DeleteIpsecTunnelRequest {
+    ipsecTunnelId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Header param: If true, the health check target in the response body will be presented using the new object format. Defaults to false. */
+    xMagicNewHcTarget?: boolean;
+}
+export declare const DeleteIpsecTunnelRequest: Schema.Schema<DeleteIpsecTunnelRequest>;
+export interface DeleteIpsecTunnelResponse {
+    deleted?: boolean | null;
+    deletedIpsecTunnel?: {
+        id: string;
+        cloudflareEndpoint: string;
+        interfaceAddress: string;
+        name: string;
+        allowNullCipher?: boolean | null;
+        automaticReturnRouting?: boolean | null;
+        bgp?: {
+            customerAsn: number;
+            extraPrefixes?: string[] | null;
+            md5Key?: string | null;
+        } | null;
+        bgpStatus?: {
+            state: "BGP_DOWN" | "BGP_UP" | "BGP_ESTABLISHING";
+            tcpEstablished: boolean;
+            updatedAt: string;
+            bgpState?: string | null;
+            cfSpeakerIp?: string | null;
+            cfSpeakerPort?: number | null;
+            customerSpeakerIp?: string | null;
+            customerSpeakerPort?: number | null;
+        } | null;
+        createdOn?: string | null;
+        customRemoteIdentities?: {
+            fqdnId?: string | null;
+        } | null;
+        customerEndpoint?: string | null;
+        description?: string | null;
+        healthCheck?: {
+            direction?: "unidirectional" | "bidirectional" | null;
+            enabled?: boolean | null;
+            rate?: "low" | "mid" | "high" | null;
+            target?: {
+                saved?: string | null;
+            } | string | null;
+            type?: "reply" | "request" | null;
+        } | null;
+        interfaceAddress6?: string | null;
+        modifiedOn?: string | null;
+        pskMetadata?: unknown | null;
+        replayProtection?: boolean | null;
+    } | null;
+}
+export declare const DeleteIpsecTunnelResponse: Schema.Schema<DeleteIpsecTunnelResponse>;
+export type DeleteIpsecTunnelError = DefaultErrors;
+export declare const deleteIpsecTunnel: API.OperationMethod<DeleteIpsecTunnelRequest, DeleteIpsecTunnelResponse, DeleteIpsecTunnelError, Credentials | HttpClient.HttpClient>;
+export interface GetPcapRequest {
+    pcapId: string;
+    /** Identifier. */
+    accountId: string;
+}
+export declare const GetPcapRequest: Schema.Schema<GetPcapRequest>;
+export type GetPcapResponse = {
+    id?: string | null;
+    filterV1?: {
+        destinationAddress?: string | null;
+        destinationPort?: number | null;
+        protocol?: number | null;
+        sourceAddress?: string | null;
+        sourcePort?: number | null;
+    } | null;
+    offsetTime?: string | null;
+    status?: "unknown" | "success" | "pending" | "running" | "conversion_pending" | "conversion_running" | "complete" | "failed" | null;
+    submitted?: string | null;
+    system?: "magic-transit" | null;
+    timeLimit?: number | null;
+    type?: "simple" | "full" | null;
+} | {
+    id?: string | null;
+    byteLimit?: number | null;
+    coloName?: string | null;
+    destinationConf?: string | null;
+    errorMessage?: string | null;
+    filterV1?: unknown | null;
+    packetsCaptured?: number | null;
+    status?: "unknown" | "success" | "pending" | "running" | "conversion_pending" | "conversion_running" | "complete" | "failed" | null;
+    stopRequested?: string | null;
+    submitted?: string | null;
+    system?: "magic-transit" | null;
+    timeLimit?: number | null;
+    type?: "simple" | "full" | null;
+};
+export declare const GetPcapResponse: Schema.Schema<GetPcapResponse>;
+export type GetPcapError = DefaultErrors;
+export declare const getPcap: API.OperationMethod<GetPcapRequest, GetPcapResponse, GetPcapError, Credentials | HttpClient.HttpClient>;
+export interface ListPcapsRequest {
+    /** Identifier. */
+    accountId: string;
+}
+export declare const ListPcapsRequest: Schema.Schema<ListPcapsRequest>;
+export type ListPcapsResponse = ({
+    id?: string | null;
+    filterV1?: {
+        destinationAddress?: string | null;
+        destinationPort?: number | null;
+        protocol?: number | null;
+        sourceAddress?: string | null;
+        sourcePort?: number | null;
+    } | null;
+    offsetTime?: string | null;
+    status?: "unknown" | "success" | "pending" | "running" | "conversion_pending" | "conversion_running" | "complete" | "failed" | null;
+    submitted?: string | null;
+    system?: "magic-transit" | null;
+    timeLimit?: number | null;
+    type?: "simple" | "full" | null;
+} | {
+    id?: string | null;
+    byteLimit?: number | null;
+    coloName?: string | null;
+    destinationConf?: string | null;
+    errorMessage?: string | null;
+    filterV1?: unknown | null;
+    packetsCaptured?: number | null;
+    status?: "unknown" | "success" | "pending" | "running" | "conversion_pending" | "conversion_running" | "complete" | "failed" | null;
+    stopRequested?: string | null;
+    submitted?: string | null;
+    system?: "magic-transit" | null;
+    timeLimit?: number | null;
+    type?: "simple" | "full" | null;
+})[];
+export declare const ListPcapsResponse: Schema.Schema<ListPcapsResponse>;
+export type ListPcapsError = DefaultErrors;
+export declare const listPcaps: API.OperationMethod<ListPcapsRequest, ListPcapsResponse, ListPcapsError, Credentials | HttpClient.HttpClient>;
+export interface CreatePcapRequest {
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: The limit of packets contained in a packet capture. */
+    packetLimit: number;
+    /** Body param: The system used to collect packet captures. */
+    system: "magic-transit";
+    /** Body param: The packet capture duration in seconds. */
+    timeLimit: number;
+    /** Body param: The type of packet capture. `Simple` captures sampled packets, and `full` captures entire payloads and non-sampled packets. */
+    type: "simple" | "full";
+    /** Body param: The packet capture filter. When this field is empty, all packets are captured. */
+    filterV1?: {
+        destinationAddress?: string;
+        destinationPort?: number;
+        protocol?: number;
+        sourceAddress?: string;
+        sourcePort?: number;
+    };
+    /** Body param: The RFC 3339 offset timestamp from which to query backwards for packets. Must be within the last 24h. When this field is empty, defaults to time of request. */
+    offsetTime?: string;
+}
+export declare const CreatePcapRequest: Schema.Schema<CreatePcapRequest>;
+export type CreatePcapResponse = {
+    id?: string | null;
+    filterV1?: {
+        destinationAddress?: string | null;
+        destinationPort?: number | null;
+        protocol?: number | null;
+        sourceAddress?: string | null;
+        sourcePort?: number | null;
+    } | null;
+    offsetTime?: string | null;
+    status?: "unknown" | "success" | "pending" | "running" | "conversion_pending" | "conversion_running" | "complete" | "failed" | null;
+    submitted?: string | null;
+    system?: "magic-transit" | null;
+    timeLimit?: number | null;
+    type?: "simple" | "full" | null;
+} | {
+    id?: string | null;
+    byteLimit?: number | null;
+    coloName?: string | null;
+    destinationConf?: string | null;
+    errorMessage?: string | null;
+    filterV1?: unknown | null;
+    packetsCaptured?: number | null;
+    status?: "unknown" | "success" | "pending" | "running" | "conversion_pending" | "conversion_running" | "complete" | "failed" | null;
+    stopRequested?: string | null;
+    submitted?: string | null;
+    system?: "magic-transit" | null;
+    timeLimit?: number | null;
+    type?: "simple" | "full" | null;
+};
+export declare const CreatePcapResponse: Schema.Schema<CreatePcapResponse>;
+export type CreatePcapError = DefaultErrors;
+export declare const createPcap: API.OperationMethod<CreatePcapRequest, CreatePcapResponse, CreatePcapError, Credentials | HttpClient.HttpClient>;
+export interface StopPcapRequest {
+    pcapId: string;
+    /** Identifier. */
+    accountId: string;
+}
+export declare const StopPcapRequest: Schema.Schema<StopPcapRequest>;
+export type StopPcapResponse = unknown;
+export declare const StopPcapResponse: Schema.Schema<unknown>;
+export type StopPcapError = DefaultErrors;
+export declare const stopPcap: API.OperationMethod<StopPcapRequest, StopPcapResponse, StopPcapError, Credentials | HttpClient.HttpClient>;
+export interface GetPcapDownloadRequest {
+    pcapId: string;
+    /** Identifier. */
+    accountId: string;
+}
+export declare const GetPcapDownloadRequest: Schema.Schema<GetPcapDownloadRequest>;
+export type GetPcapDownloadResponse = unknown;
+export declare const GetPcapDownloadResponse: Schema.Schema<unknown>;
+export type GetPcapDownloadError = DefaultErrors;
+export declare const getPcapDownload: API.OperationMethod<GetPcapDownloadRequest, GetPcapDownloadResponse, GetPcapDownloadError, Credentials | HttpClient.HttpClient>;
+export interface GetPcapOwnershipRequest {
+    /** Identifier. */
+    accountId: string;
+}
+export declare const GetPcapOwnershipRequest: Schema.Schema<GetPcapOwnershipRequest>;
+export type GetPcapOwnershipResponse = {
+    id: string;
+    destinationConf: string;
+    filename: string;
+    status: "pending" | "success" | "failed";
+    submitted: string;
+    validated?: string | null;
+}[];
+export declare const GetPcapOwnershipResponse: Schema.Schema<GetPcapOwnershipResponse>;
+export type GetPcapOwnershipError = DefaultErrors;
+export declare const getPcapOwnership: API.OperationMethod<GetPcapOwnershipRequest, GetPcapOwnershipResponse, GetPcapOwnershipError, Credentials | HttpClient.HttpClient>;
+export interface CreatePcapOwnershipRequest {
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: The full URI for the bucket. This field only applies to `full` packet captures. */
+    destinationConf: string;
+}
+export declare const CreatePcapOwnershipRequest: Schema.Schema<CreatePcapOwnershipRequest>;
+export interface CreatePcapOwnershipResponse {
+    /** The bucket ID associated with the packet captures API. */
+    id: string;
+    /** The full URI for the bucket. This field only applies to `full` packet captures. */
+    destinationConf: string;
+    /** The ownership challenge filename stored in the bucket. */
+    filename: string;
+    /** The status of the ownership challenge. Can be pending, success or failed. */
+    status: "pending" | "success" | "failed";
+    /** The RFC 3339 timestamp when the bucket was added to packet captures API. */
+    submitted: string;
+    /** The RFC 3339 timestamp when the bucket was validated. */
+    validated?: string | null;
+}
+export declare const CreatePcapOwnershipResponse: Schema.Schema<CreatePcapOwnershipResponse>;
+export type CreatePcapOwnershipError = DefaultErrors;
+export declare const createPcapOwnership: API.OperationMethod<CreatePcapOwnershipRequest, CreatePcapOwnershipResponse, CreatePcapOwnershipError, Credentials | HttpClient.HttpClient>;
+export interface DeletePcapOwnershipRequest {
+    ownershipId: string;
+    /** Identifier. */
+    accountId: string;
+}
+export declare const DeletePcapOwnershipRequest: Schema.Schema<DeletePcapOwnershipRequest>;
+export type DeletePcapOwnershipResponse = unknown;
+export declare const DeletePcapOwnershipResponse: Schema.Schema<unknown>;
+export type DeletePcapOwnershipError = DefaultErrors;
+export declare const deletePcapOwnership: API.OperationMethod<DeletePcapOwnershipRequest, DeletePcapOwnershipResponse, DeletePcapOwnershipError, Credentials | HttpClient.HttpClient>;
+export interface ValidatePcapOwnershipRequest {
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: The full URI for the bucket. This field only applies to `full` packet captures. */
+    destinationConf: string;
+    /** Body param: The ownership challenge filename stored in the bucket. */
+    ownershipChallenge: string;
+}
+export declare const ValidatePcapOwnershipRequest: Schema.Schema<ValidatePcapOwnershipRequest>;
+export interface ValidatePcapOwnershipResponse {
+    /** The bucket ID associated with the packet captures API. */
+    id: string;
+    /** The full URI for the bucket. This field only applies to `full` packet captures. */
+    destinationConf: string;
+    /** The ownership challenge filename stored in the bucket. */
+    filename: string;
+    /** The status of the ownership challenge. Can be pending, success or failed. */
+    status: "pending" | "success" | "failed";
+    /** The RFC 3339 timestamp when the bucket was added to packet captures API. */
+    submitted: string;
+    /** The RFC 3339 timestamp when the bucket was validated. */
+    validated?: string | null;
+}
+export declare const ValidatePcapOwnershipResponse: Schema.Schema<ValidatePcapOwnershipResponse>;
+export type ValidatePcapOwnershipError = DefaultErrors;
+export declare const validatePcapOwnership: API.OperationMethod<ValidatePcapOwnershipRequest, ValidatePcapOwnershipResponse, ValidatePcapOwnershipError, Credentials | HttpClient.HttpClient>;
+export interface BulkPutCfInterconnectsRequest {
+    /** Path param: Identifier */
+    accountId: string;
+    /** Header param: If true, the health check target in the request and response bodies will be presented using the new object format. Defaults to false. */
+    xMagicNewHcTarget?: boolean;
+    /** Body param: */
+    body: unknown;
+}
+export declare const BulkPutCfInterconnectsRequest: Schema.Schema<BulkPutCfInterconnectsRequest>;
+export interface BulkPutCfInterconnectsResponse {
+    modified?: boolean | null;
+    modifiedInterconnects?: {
+        id?: string | null;
+        automaticReturnRouting?: boolean | null;
+        coloName?: string | null;
+        createdOn?: string | null;
+        description?: string | null;
+        gre?: {
+            cloudflareEndpoint?: string | null;
+        } | null;
+        healthCheck?: unknown | null;
+        interfaceAddress?: string | null;
+        interfaceAddress6?: string | null;
+        modifiedOn?: string | null;
+        mtu?: number | null;
+        name?: string | null;
+    }[] | null;
+}
+export declare const BulkPutCfInterconnectsResponse: Schema.Schema<BulkPutCfInterconnectsResponse>;
+export type BulkPutCfInterconnectsError = DefaultErrors;
+export declare const bulkPutCfInterconnects: API.OperationMethod<BulkPutCfInterconnectsRequest, BulkPutCfInterconnectsResponse, BulkPutCfInterconnectsError, Credentials | HttpClient.HttpClient>;
+export interface BulkPutGreTunnelsRequest {
+    /** Path param: Identifier */
+    accountId: string;
+    /** Header param: If true, the health check target in the request and response bodies will be presented using the new object format. Defaults to false. */
+    xMagicNewHcTarget?: boolean;
+    /** Body param: */
+    body: unknown;
+}
+export declare const BulkPutGreTunnelsRequest: Schema.Schema<BulkPutGreTunnelsRequest>;
+export interface BulkPutGreTunnelsResponse {
+    modified?: boolean | null;
+    modifiedGreTunnels?: {
+        id: string;
+        cloudflareGreEndpoint: string;
+        customerGreEndpoint: string;
+        interfaceAddress: string;
+        name: string;
+        automaticReturnRouting?: boolean | null;
+        bgp?: {
+            customerAsn: number;
+            extraPrefixes?: string[] | null;
+            md5Key?: string | null;
+        } | null;
+        bgpStatus?: {
+            state: "BGP_DOWN" | "BGP_UP" | "BGP_ESTABLISHING";
+            tcpEstablished: boolean;
+            updatedAt: string;
+            bgpState?: string | null;
+            cfSpeakerIp?: string | null;
+            cfSpeakerPort?: number | null;
+            customerSpeakerIp?: string | null;
+            customerSpeakerPort?: number | null;
+        } | null;
+        createdOn?: string | null;
+        description?: string | null;
+        healthCheck?: {
+            direction?: "unidirectional" | "bidirectional" | null;
+            enabled?: boolean | null;
+            rate?: "low" | "mid" | "high" | null;
+            target?: {
+                saved?: string | null;
+            } | string | null;
+            type?: "reply" | "request" | null;
+        } | null;
+        interfaceAddress6?: string | null;
+        modifiedOn?: string | null;
+        mtu?: number | null;
+        ttl?: number | null;
+    }[] | null;
+}
+export declare const BulkPutGreTunnelsResponse: Schema.Schema<BulkPutGreTunnelsResponse>;
+export type BulkPutGreTunnelsError = DefaultErrors;
+export declare const bulkPutGreTunnels: API.OperationMethod<BulkPutGreTunnelsRequest, BulkPutGreTunnelsResponse, BulkPutGreTunnelsError, Credentials | HttpClient.HttpClient>;
+export interface BulkPutIpsecTunnelsRequest {
+    /** Path param: Identifier */
+    accountId: string;
+    /** Header param: If true, the health check target in the request and response bodies will be presented using the new object format. Defaults to false. */
+    xMagicNewHcTarget?: boolean;
+    /** Body param: */
+    body: unknown;
+}
+export declare const BulkPutIpsecTunnelsRequest: Schema.Schema<BulkPutIpsecTunnelsRequest>;
+export interface BulkPutIpsecTunnelsResponse {
+    modified?: boolean | null;
+    modifiedIpsecTunnels?: {
+        id: string;
+        cloudflareEndpoint: string;
+        interfaceAddress: string;
+        name: string;
+        allowNullCipher?: boolean | null;
+        automaticReturnRouting?: boolean | null;
+        bgp?: {
+            customerAsn: number;
+            extraPrefixes?: string[] | null;
+            md5Key?: string | null;
+        } | null;
+        bgpStatus?: {
+            state: "BGP_DOWN" | "BGP_UP" | "BGP_ESTABLISHING";
+            tcpEstablished: boolean;
+            updatedAt: string;
+            bgpState?: string | null;
+            cfSpeakerIp?: string | null;
+            cfSpeakerPort?: number | null;
+            customerSpeakerIp?: string | null;
+            customerSpeakerPort?: number | null;
+        } | null;
+        createdOn?: string | null;
+        customRemoteIdentities?: {
+            fqdnId?: string | null;
+        } | null;
+        customerEndpoint?: string | null;
+        description?: string | null;
+        healthCheck?: {
+            direction?: "unidirectional" | "bidirectional" | null;
+            enabled?: boolean | null;
+            rate?: "low" | "mid" | "high" | null;
+            target?: {
+                saved?: string | null;
+            } | string | null;
+            type?: "reply" | "request" | null;
+        } | null;
+        interfaceAddress6?: string | null;
+        modifiedOn?: string | null;
+        pskMetadata?: unknown | null;
+        replayProtection?: boolean | null;
+    }[] | null;
+}
+export declare const BulkPutIpsecTunnelsResponse: Schema.Schema<BulkPutIpsecTunnelsResponse>;
+export type BulkPutIpsecTunnelsError = DefaultErrors;
+export declare const bulkPutIpsecTunnels: API.OperationMethod<BulkPutIpsecTunnelsRequest, BulkPutIpsecTunnelsResponse, BulkPutIpsecTunnelsError, Credentials | HttpClient.HttpClient>;
+export interface BulkPutRoutesRequest {
+    /** Path param: Identifier */
+    accountId: string;
+    /** Body param: */
+    routes: {
+        id: string;
+        nexthop: string;
+        prefix: string;
+        priority: number;
+        description?: string;
+        scope?: unknown;
+        weight?: number;
+    }[];
+}
+export declare const BulkPutRoutesRequest: Schema.Schema<BulkPutRoutesRequest>;
+export interface BulkPutRoutesResponse {
+    modified?: boolean | null;
+    modifiedRoutes?: {
+        id: string;
+        nexthop: string;
+        prefix: string;
+        priority: number;
+        createdOn?: string | null;
+        description?: string | null;
+        modifiedOn?: string | null;
+        scope?: unknown | null;
+        weight?: number | null;
+    }[] | null;
+}
+export declare const BulkPutRoutesResponse: Schema.Schema<BulkPutRoutesResponse>;
+export type BulkPutRoutesError = DefaultErrors;
+export declare const bulkPutRoutes: API.OperationMethod<BulkPutRoutesRequest, BulkPutRoutesResponse, BulkPutRoutesError, Credentials | HttpClient.HttpClient>;
+export interface GetRouteRequest {
+    routeId: string;
+    /** Identifier */
+    accountId: string;
+}
+export declare const GetRouteRequest: Schema.Schema<GetRouteRequest>;
+export interface GetRouteResponse {
+    route?: {
+        id: string;
+        nexthop: string;
+        prefix: string;
+        priority: number;
+        createdOn?: string | null;
+        description?: string | null;
+        modifiedOn?: string | null;
+        scope?: unknown | null;
+        weight?: number | null;
+    } | null;
+}
+export declare const GetRouteResponse: Schema.Schema<GetRouteResponse>;
+export type GetRouteError = DefaultErrors;
+export declare const getRoute: API.OperationMethod<GetRouteRequest, GetRouteResponse, GetRouteError, Credentials | HttpClient.HttpClient>;
+export interface ListRoutesRequest {
+    /** Identifier */
+    accountId: string;
+}
+export declare const ListRoutesRequest: Schema.Schema<ListRoutesRequest>;
+export interface ListRoutesResponse {
+    routes?: {
+        id: string;
+        nexthop: string;
+        prefix: string;
+        priority: number;
+        createdOn?: string | null;
+        description?: string | null;
+        modifiedOn?: string | null;
+        scope?: unknown | null;
+        weight?: number | null;
+    }[] | null;
+}
+export declare const ListRoutesResponse: Schema.Schema<ListRoutesResponse>;
+export type ListRoutesError = DefaultErrors;
+export declare const listRoutes: API.OperationMethod<ListRoutesRequest, ListRoutesResponse, ListRoutesError, Credentials | HttpClient.HttpClient>;
+export interface CreateRouteRequest {
+    /** Path param: Identifier */
+    accountId: string;
+    /** Body param: The next-hop IP Address for the static route. */
+    nexthop: string;
+    /** Body param: IP Prefix in Classless Inter-Domain Routing format. */
+    prefix: string;
+    /** Body param: Priority of the static route. */
+    priority: number;
+    /** Body param: An optional human provided description of the static route. */
+    description?: string;
+    /** Body param: Used only for ECMP routes. */
+    scope?: {
+        coloNames?: string[];
+        coloRegions?: string[];
+    };
+    /** Body param: Optional weight of the ECMP scope - if provided. */
+    weight?: number;
+}
+export declare const CreateRouteRequest: Schema.Schema<CreateRouteRequest>;
+export interface CreateRouteResponse {
+    /** Identifier */
+    id: string;
+    /** The next-hop IP Address for the static route. */
+    nexthop: string;
+    /** IP Prefix in Classless Inter-Domain Routing format. */
+    prefix: string;
+    /** Priority of the static route. */
+    priority: number;
+    /** When the route was created. */
+    createdOn?: string | null;
+    /** An optional human provided description of the static route. */
+    description?: string | null;
+    /** When the route was last modified. */
+    modifiedOn?: string | null;
+    /** Used only for ECMP routes. */
+    scope?: {
+        coloNames?: string[] | null;
+        coloRegions?: string[] | null;
+    } | null;
+    /** Optional weight of the ECMP scope - if provided. */
+    weight?: number | null;
+}
+export declare const CreateRouteResponse: Schema.Schema<CreateRouteResponse>;
+export type CreateRouteError = DefaultErrors;
+export declare const createRoute: API.OperationMethod<CreateRouteRequest, CreateRouteResponse, CreateRouteError, Credentials | HttpClient.HttpClient>;
+export interface UpdateRouteRequest {
+    routeId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Body param: The next-hop IP Address for the static route. */
+    nexthop: string;
+    /** Body param: IP Prefix in Classless Inter-Domain Routing format. */
+    prefix: string;
+    /** Body param: Priority of the static route. */
+    priority: number;
+    /** Body param: An optional human provided description of the static route. */
+    description?: string;
+    /** Body param: Used only for ECMP routes. */
+    scope?: {
+        coloNames?: string[];
+        coloRegions?: string[];
+    };
+    /** Body param: Optional weight of the ECMP scope - if provided. */
+    weight?: number;
+}
+export declare const UpdateRouteRequest: Schema.Schema<UpdateRouteRequest>;
+export interface UpdateRouteResponse {
+    modified?: boolean | null;
+    modifiedRoute?: {
+        id: string;
+        nexthop: string;
+        prefix: string;
+        priority: number;
+        createdOn?: string | null;
+        description?: string | null;
+        modifiedOn?: string | null;
+        scope?: unknown | null;
+        weight?: number | null;
+    } | null;
+}
+export declare const UpdateRouteResponse: Schema.Schema<UpdateRouteResponse>;
+export type UpdateRouteError = DefaultErrors;
+export declare const updateRoute: API.OperationMethod<UpdateRouteRequest, UpdateRouteResponse, UpdateRouteError, Credentials | HttpClient.HttpClient>;
+export interface DeleteRouteRequest {
+    routeId: string;
+    /** Identifier */
+    accountId: string;
+}
+export declare const DeleteRouteRequest: Schema.Schema<DeleteRouteRequest>;
+export interface DeleteRouteResponse {
+    deleted?: boolean | null;
+    deletedRoute?: {
+        id: string;
+        nexthop: string;
+        prefix: string;
+        priority: number;
+        createdOn?: string | null;
+        description?: string | null;
+        modifiedOn?: string | null;
+        scope?: unknown | null;
+        weight?: number | null;
+    } | null;
+}
+export declare const DeleteRouteResponse: Schema.Schema<DeleteRouteResponse>;
+export type DeleteRouteError = DefaultErrors;
+export declare const deleteRoute: API.OperationMethod<DeleteRouteRequest, DeleteRouteResponse, DeleteRouteError, Credentials | HttpClient.HttpClient>;
+export interface EmptyRouteRequest {
+    /** Identifier */
+    accountId: string;
+}
+export declare const EmptyRouteRequest: Schema.Schema<EmptyRouteRequest>;
+export interface EmptyRouteResponse {
+    deleted?: boolean | null;
+    deletedRoutes?: {
+        id: string;
+        nexthop: string;
+        prefix: string;
+        priority: number;
+        createdOn?: string | null;
+        description?: string | null;
+        modifiedOn?: string | null;
+        scope?: unknown | null;
+        weight?: number | null;
+    }[] | null;
+}
+export declare const EmptyRouteResponse: Schema.Schema<EmptyRouteResponse>;
+export type EmptyRouteError = DefaultErrors;
+export declare const emptyRoute: API.OperationMethod<EmptyRouteRequest, EmptyRouteResponse, EmptyRouteError, Credentials | HttpClient.HttpClient>;
+export interface GetSiteRequest {
+    siteId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Header param: If true, the health check target in the response body will be presented using the new object format. Defaults to false. */
+    xMagicNewHcTarget?: boolean;
+}
+export declare const GetSiteRequest: Schema.Schema<GetSiteRequest>;
+export interface GetSiteResponse {
+    /** Identifier */
+    id?: string | null;
+    /** Magic Connector identifier tag. */
+    connectorId?: string | null;
+    description?: string | null;
+    /** Site high availability mode. If set to true, the site can have two connectors and runs in high availability mode. */
+    haMode?: boolean | null;
+    /** Location of site in latitude and longitude. */
+    location?: {
+        lat?: string | null;
+        lon?: string | null;
+    } | null;
+    /** The name of the site. */
+    name?: string | null;
+    /** Magic Connector identifier tag. Used when high availability mode is on. */
+    secondaryConnectorId?: string | null;
+}
+export declare const GetSiteResponse: Schema.Schema<GetSiteResponse>;
+export type GetSiteError = DefaultErrors;
+export declare const getSite: API.OperationMethod<GetSiteRequest, GetSiteResponse, GetSiteError, Credentials | HttpClient.HttpClient>;
+export interface ListSitesRequest {
+    /** Path param: Identifier */
+    accountId: string;
+    /** Query param: Identifier */
+    connectorid?: string;
+}
+export declare const ListSitesRequest: Schema.Schema<ListSitesRequest>;
+export type ListSitesResponse = {
+    id?: string | null;
+    connectorId?: string | null;
+    description?: string | null;
+    haMode?: boolean | null;
+    location?: {
+        lat?: string | null;
+        lon?: string | null;
+    } | null;
+    name?: string | null;
+    secondaryConnectorId?: string | null;
+}[];
+export declare const ListSitesResponse: Schema.Schema<ListSitesResponse>;
+export type ListSitesError = DefaultErrors;
+export declare const listSites: API.OperationMethod<ListSitesRequest, ListSitesResponse, ListSitesError, Credentials | HttpClient.HttpClient>;
+export interface CreateSiteRequest {
+    /** Path param: Identifier */
+    accountId: string;
+    /** Body param: The name of the site. */
+    name: string;
+    /** Body param: Magic Connector identifier tag. */
+    connectorId?: string;
+    /** Body param: */
+    description?: string;
+    /** Body param: Site high availability mode. If set to true, the site can have two connectors and runs in high availability mode. */
+    haMode?: boolean;
+    /** Body param: Location of site in latitude and longitude. */
+    location?: {
+        lat?: string;
+        lon?: string;
+    };
+    /** Body param: Magic Connector identifier tag. Used when high availability mode is on. */
+    secondaryConnectorId?: string;
+}
+export declare const CreateSiteRequest: Schema.Schema<CreateSiteRequest>;
+export interface CreateSiteResponse {
+    /** Identifier */
+    id?: string | null;
+    /** Magic Connector identifier tag. */
+    connectorId?: string | null;
+    description?: string | null;
+    /** Site high availability mode. If set to true, the site can have two connectors and runs in high availability mode. */
+    haMode?: boolean | null;
+    /** Location of site in latitude and longitude. */
+    location?: {
+        lat?: string | null;
+        lon?: string | null;
+    } | null;
+    /** The name of the site. */
+    name?: string | null;
+    /** Magic Connector identifier tag. Used when high availability mode is on. */
+    secondaryConnectorId?: string | null;
+}
+export declare const CreateSiteResponse: Schema.Schema<CreateSiteResponse>;
+export type CreateSiteError = DefaultErrors;
+export declare const createSite: API.OperationMethod<CreateSiteRequest, CreateSiteResponse, CreateSiteError, Credentials | HttpClient.HttpClient>;
+export interface UpdateSiteRequest {
+    siteId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Body param: Magic Connector identifier tag. */
+    connectorId?: string;
+    /** Body param: */
+    description?: string;
+    /** Body param: Location of site in latitude and longitude. */
+    location?: {
+        lat?: string;
+        lon?: string;
+    };
+    /** Body param: The name of the site. */
+    name?: string;
+    /** Body param: Magic Connector identifier tag. Used when high availability mode is on. */
+    secondaryConnectorId?: string;
+}
+export declare const UpdateSiteRequest: Schema.Schema<UpdateSiteRequest>;
+export interface UpdateSiteResponse {
+    /** Identifier */
+    id?: string | null;
+    /** Magic Connector identifier tag. */
+    connectorId?: string | null;
+    description?: string | null;
+    /** Site high availability mode. If set to true, the site can have two connectors and runs in high availability mode. */
+    haMode?: boolean | null;
+    /** Location of site in latitude and longitude. */
+    location?: {
+        lat?: string | null;
+        lon?: string | null;
+    } | null;
+    /** The name of the site. */
+    name?: string | null;
+    /** Magic Connector identifier tag. Used when high availability mode is on. */
+    secondaryConnectorId?: string | null;
+}
+export declare const UpdateSiteResponse: Schema.Schema<UpdateSiteResponse>;
+export type UpdateSiteError = DefaultErrors;
+export declare const updateSite: API.OperationMethod<UpdateSiteRequest, UpdateSiteResponse, UpdateSiteError, Credentials | HttpClient.HttpClient>;
+export interface PatchSiteRequest {
+    siteId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Body param: Magic Connector identifier tag. */
+    connectorId?: string;
+    /** Body param: */
+    description?: string;
+    /** Body param: Location of site in latitude and longitude. */
+    location?: {
+        lat?: string;
+        lon?: string;
+    };
+    /** Body param: The name of the site. */
+    name?: string;
+    /** Body param: Magic Connector identifier tag. Used when high availability mode is on. */
+    secondaryConnectorId?: string;
+}
+export declare const PatchSiteRequest: Schema.Schema<PatchSiteRequest>;
+export interface PatchSiteResponse {
+    /** Identifier */
+    id?: string | null;
+    /** Magic Connector identifier tag. */
+    connectorId?: string | null;
+    description?: string | null;
+    /** Site high availability mode. If set to true, the site can have two connectors and runs in high availability mode. */
+    haMode?: boolean | null;
+    /** Location of site in latitude and longitude. */
+    location?: {
+        lat?: string | null;
+        lon?: string | null;
+    } | null;
+    /** The name of the site. */
+    name?: string | null;
+    /** Magic Connector identifier tag. Used when high availability mode is on. */
+    secondaryConnectorId?: string | null;
+}
+export declare const PatchSiteResponse: Schema.Schema<PatchSiteResponse>;
+export type PatchSiteError = DefaultErrors;
+export declare const patchSite: API.OperationMethod<PatchSiteRequest, PatchSiteResponse, PatchSiteError, Credentials | HttpClient.HttpClient>;
+export interface DeleteSiteRequest {
+    siteId: string;
+    /** Identifier */
+    accountId: string;
+}
+export declare const DeleteSiteRequest: Schema.Schema<DeleteSiteRequest>;
+export interface DeleteSiteResponse {
+    /** Identifier */
+    id?: string | null;
+    /** Magic Connector identifier tag. */
+    connectorId?: string | null;
+    description?: string | null;
+    /** Site high availability mode. If set to true, the site can have two connectors and runs in high availability mode. */
+    haMode?: boolean | null;
+    /** Location of site in latitude and longitude. */
+    location?: {
+        lat?: string | null;
+        lon?: string | null;
+    } | null;
+    /** The name of the site. */
+    name?: string | null;
+    /** Magic Connector identifier tag. Used when high availability mode is on. */
+    secondaryConnectorId?: string | null;
+}
+export declare const DeleteSiteResponse: Schema.Schema<DeleteSiteResponse>;
+export type DeleteSiteError = DefaultErrors;
+export declare const deleteSite: API.OperationMethod<DeleteSiteRequest, DeleteSiteResponse, DeleteSiteError, Credentials | HttpClient.HttpClient>;
+export interface GetSiteAclRequest {
+    siteId: string;
+    aclId: string;
+    /** Identifier */
+    accountId: string;
+}
+export declare const GetSiteAclRequest: Schema.Schema<GetSiteAclRequest>;
+export interface GetSiteAclResponse {
+    /** Identifier */
+    id?: string | null;
+    /** Description for the ACL. */
+    description?: string | null;
+    /** The desired forwarding action for this ACL policy. If set to "false", the policy will forward traffic to Cloudflare. If set to "true", the policy will forward traffic locally on the Magic Connector. I */
+    forwardLocally?: boolean | null;
+    lan_1?: {
+        lanId: string;
+        lanName?: string | null;
+        portRanges?: string[] | null;
+        ports?: number[] | null;
+        subnets?: string[] | null;
+    } | null;
+    lan_2?: {
+        lanId: string;
+        lanName?: string | null;
+        portRanges?: string[] | null;
+        ports?: number[] | null;
+        subnets?: string[] | null;
+    } | null;
+    /** The name of the ACL. */
+    name?: string | null;
+    protocols?: ("tcp" | "udp" | "icmp")[] | null;
+    /** The desired traffic direction for this ACL policy. If set to "false", the policy will allow bidirectional traffic. If set to "true", the policy will only allow traffic in one direction. If not include */
+    unidirectional?: boolean | null;
+}
+export declare const GetSiteAclResponse: Schema.Schema<GetSiteAclResponse>;
+export type GetSiteAclError = DefaultErrors;
+export declare const getSiteAcl: API.OperationMethod<GetSiteAclRequest, GetSiteAclResponse, GetSiteAclError, Credentials | HttpClient.HttpClient>;
+export interface ListSiteAclsRequest {
+    siteId: string;
+    /** Identifier */
+    accountId: string;
+}
+export declare const ListSiteAclsRequest: Schema.Schema<ListSiteAclsRequest>;
+export type ListSiteAclsResponse = {
+    id?: string | null;
+    description?: string | null;
+    forwardLocally?: boolean | null;
+    lan_1?: {
+        lanId: string;
+        lanName?: string | null;
+        portRanges?: string[] | null;
+        ports?: number[] | null;
+        subnets?: string[] | null;
+    } | null;
+    lan_2?: {
+        lanId: string;
+        lanName?: string | null;
+        portRanges?: string[] | null;
+        ports?: number[] | null;
+        subnets?: string[] | null;
+    } | null;
+    name?: string | null;
+    protocols?: ("tcp" | "udp" | "icmp")[] | null;
+    unidirectional?: boolean | null;
+}[];
+export declare const ListSiteAclsResponse: Schema.Schema<ListSiteAclsResponse>;
+export type ListSiteAclsError = DefaultErrors;
+export declare const listSiteAcls: API.OperationMethod<ListSiteAclsRequest, ListSiteAclsResponse, ListSiteAclsError, Credentials | HttpClient.HttpClient>;
+export interface CreateSiteAclRequest {
+    siteId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Body param: */
+    lan_1: {
+        lanId: string;
+        lanName?: string;
+        portRanges?: string[];
+        ports?: number[];
+        subnets?: string[];
+    };
+    /** Body param: */
+    lan_2: {
+        lanId: string;
+        lanName?: string;
+        portRanges?: string[];
+        ports?: number[];
+        subnets?: string[];
+    };
+    /** Body param: The name of the ACL. */
+    name: string;
+    /** Body param: Description for the ACL. */
+    description?: string;
+    /** Body param: The desired forwarding action for this ACL policy. If set to "false", the policy will forward traffic to Cloudflare. If set to "true", the policy will forward traffic locally on the Magic  */
+    forwardLocally?: boolean;
+    /** Body param: */
+    protocols?: ("tcp" | "udp" | "icmp")[];
+    /** Body param: The desired traffic direction for this ACL policy. If set to "false", the policy will allow bidirectional traffic. If set to "true", the policy will only allow traffic in one direction. If */
+    unidirectional?: boolean;
+}
+export declare const CreateSiteAclRequest: Schema.Schema<CreateSiteAclRequest>;
+export interface CreateSiteAclResponse {
+    /** Identifier */
+    id?: string | null;
+    /** Description for the ACL. */
+    description?: string | null;
+    /** The desired forwarding action for this ACL policy. If set to "false", the policy will forward traffic to Cloudflare. If set to "true", the policy will forward traffic locally on the Magic Connector. I */
+    forwardLocally?: boolean | null;
+    lan_1?: {
+        lanId: string;
+        lanName?: string | null;
+        portRanges?: string[] | null;
+        ports?: number[] | null;
+        subnets?: string[] | null;
+    } | null;
+    lan_2?: {
+        lanId: string;
+        lanName?: string | null;
+        portRanges?: string[] | null;
+        ports?: number[] | null;
+        subnets?: string[] | null;
+    } | null;
+    /** The name of the ACL. */
+    name?: string | null;
+    protocols?: ("tcp" | "udp" | "icmp")[] | null;
+    /** The desired traffic direction for this ACL policy. If set to "false", the policy will allow bidirectional traffic. If set to "true", the policy will only allow traffic in one direction. If not include */
+    unidirectional?: boolean | null;
+}
+export declare const CreateSiteAclResponse: Schema.Schema<CreateSiteAclResponse>;
+export type CreateSiteAclError = DefaultErrors;
+export declare const createSiteAcl: API.OperationMethod<CreateSiteAclRequest, CreateSiteAclResponse, CreateSiteAclError, Credentials | HttpClient.HttpClient>;
+export interface UpdateSiteAclRequest {
+    siteId: string;
+    aclId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Body param: Description for the ACL. */
+    description?: string;
+    /** Body param: The desired forwarding action for this ACL policy. If set to "false", the policy will forward traffic to Cloudflare. If set to "true", the policy will forward traffic locally on the Magic  */
+    forwardLocally?: boolean;
+    /** Body param: */
+    lan_1?: {
+        lanId: string;
+        lanName?: string;
+        portRanges?: string[];
+        ports?: number[];
+        subnets?: string[];
+    };
+    /** Body param: */
+    lan_2?: {
+        lanId: string;
+        lanName?: string;
+        portRanges?: string[];
+        ports?: number[];
+        subnets?: string[];
+    };
+    /** Body param: The name of the ACL. */
+    name?: string;
+    /** Body param: */
+    protocols?: ("tcp" | "udp" | "icmp")[];
+    /** Body param: The desired traffic direction for this ACL policy. If set to "false", the policy will allow bidirectional traffic. If set to "true", the policy will only allow traffic in one direction. If */
+    unidirectional?: boolean;
+}
+export declare const UpdateSiteAclRequest: Schema.Schema<UpdateSiteAclRequest>;
+export interface UpdateSiteAclResponse {
+    /** Identifier */
+    id?: string | null;
+    /** Description for the ACL. */
+    description?: string | null;
+    /** The desired forwarding action for this ACL policy. If set to "false", the policy will forward traffic to Cloudflare. If set to "true", the policy will forward traffic locally on the Magic Connector. I */
+    forwardLocally?: boolean | null;
+    lan_1?: {
+        lanId: string;
+        lanName?: string | null;
+        portRanges?: string[] | null;
+        ports?: number[] | null;
+        subnets?: string[] | null;
+    } | null;
+    lan_2?: {
+        lanId: string;
+        lanName?: string | null;
+        portRanges?: string[] | null;
+        ports?: number[] | null;
+        subnets?: string[] | null;
+    } | null;
+    /** The name of the ACL. */
+    name?: string | null;
+    protocols?: ("tcp" | "udp" | "icmp")[] | null;
+    /** The desired traffic direction for this ACL policy. If set to "false", the policy will allow bidirectional traffic. If set to "true", the policy will only allow traffic in one direction. If not include */
+    unidirectional?: boolean | null;
+}
+export declare const UpdateSiteAclResponse: Schema.Schema<UpdateSiteAclResponse>;
+export type UpdateSiteAclError = DefaultErrors;
+export declare const updateSiteAcl: API.OperationMethod<UpdateSiteAclRequest, UpdateSiteAclResponse, UpdateSiteAclError, Credentials | HttpClient.HttpClient>;
+export interface PatchSiteAclRequest {
+    siteId: string;
+    aclId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Body param: Description for the ACL. */
+    description?: string;
+    /** Body param: The desired forwarding action for this ACL policy. If set to "false", the policy will forward traffic to Cloudflare. If set to "true", the policy will forward traffic locally on the Magic  */
+    forwardLocally?: boolean;
+    /** Body param: */
+    lan_1?: {
+        lanId: string;
+        lanName?: string;
+        portRanges?: string[];
+        ports?: number[];
+        subnets?: string[];
+    };
+    /** Body param: */
+    lan_2?: {
+        lanId: string;
+        lanName?: string;
+        portRanges?: string[];
+        ports?: number[];
+        subnets?: string[];
+    };
+    /** Body param: The name of the ACL. */
+    name?: string;
+    /** Body param: */
+    protocols?: ("tcp" | "udp" | "icmp")[];
+    /** Body param: The desired traffic direction for this ACL policy. If set to "false", the policy will allow bidirectional traffic. If set to "true", the policy will only allow traffic in one direction. If */
+    unidirectional?: boolean;
+}
+export declare const PatchSiteAclRequest: Schema.Schema<PatchSiteAclRequest>;
+export interface PatchSiteAclResponse {
+    /** Identifier */
+    id?: string | null;
+    /** Description for the ACL. */
+    description?: string | null;
+    /** The desired forwarding action for this ACL policy. If set to "false", the policy will forward traffic to Cloudflare. If set to "true", the policy will forward traffic locally on the Magic Connector. I */
+    forwardLocally?: boolean | null;
+    lan_1?: {
+        lanId: string;
+        lanName?: string | null;
+        portRanges?: string[] | null;
+        ports?: number[] | null;
+        subnets?: string[] | null;
+    } | null;
+    lan_2?: {
+        lanId: string;
+        lanName?: string | null;
+        portRanges?: string[] | null;
+        ports?: number[] | null;
+        subnets?: string[] | null;
+    } | null;
+    /** The name of the ACL. */
+    name?: string | null;
+    protocols?: ("tcp" | "udp" | "icmp")[] | null;
+    /** The desired traffic direction for this ACL policy. If set to "false", the policy will allow bidirectional traffic. If set to "true", the policy will only allow traffic in one direction. If not include */
+    unidirectional?: boolean | null;
+}
+export declare const PatchSiteAclResponse: Schema.Schema<PatchSiteAclResponse>;
+export type PatchSiteAclError = DefaultErrors;
+export declare const patchSiteAcl: API.OperationMethod<PatchSiteAclRequest, PatchSiteAclResponse, PatchSiteAclError, Credentials | HttpClient.HttpClient>;
+export interface DeleteSiteAclRequest {
+    siteId: string;
+    aclId: string;
+    /** Identifier */
+    accountId: string;
+}
+export declare const DeleteSiteAclRequest: Schema.Schema<DeleteSiteAclRequest>;
+export interface DeleteSiteAclResponse {
+    /** Identifier */
+    id?: string | null;
+    /** Description for the ACL. */
+    description?: string | null;
+    /** The desired forwarding action for this ACL policy. If set to "false", the policy will forward traffic to Cloudflare. If set to "true", the policy will forward traffic locally on the Magic Connector. I */
+    forwardLocally?: boolean | null;
+    lan_1?: {
+        lanId: string;
+        lanName?: string | null;
+        portRanges?: string[] | null;
+        ports?: number[] | null;
+        subnets?: string[] | null;
+    } | null;
+    lan_2?: {
+        lanId: string;
+        lanName?: string | null;
+        portRanges?: string[] | null;
+        ports?: number[] | null;
+        subnets?: string[] | null;
+    } | null;
+    /** The name of the ACL. */
+    name?: string | null;
+    protocols?: ("tcp" | "udp" | "icmp")[] | null;
+    /** The desired traffic direction for this ACL policy. If set to "false", the policy will allow bidirectional traffic. If set to "true", the policy will only allow traffic in one direction. If not include */
+    unidirectional?: boolean | null;
+}
+export declare const DeleteSiteAclResponse: Schema.Schema<DeleteSiteAclResponse>;
+export type DeleteSiteAclError = DefaultErrors;
+export declare const deleteSiteAcl: API.OperationMethod<DeleteSiteAclRequest, DeleteSiteAclResponse, DeleteSiteAclError, Credentials | HttpClient.HttpClient>;
+export interface GetSiteLanRequest {
+    siteId: string;
+    lanId: string;
+    /** Identifier */
+    accountId: string;
+}
+export declare const GetSiteLanRequest: Schema.Schema<GetSiteLanRequest>;
+export interface GetSiteLanResponse {
+    /** Identifier */
+    id?: string | null;
+    /** mark true to use this LAN for HA probing. only works for site with HA turned on. only one LAN can be set as the ha_link. */
+    haLink?: boolean | null;
+    name?: string | null;
+    nat?: {
+        staticPrefix?: string | null;
+    } | null;
+    physport?: number | null;
+    routedSubnets?: {
+        nextHop: string;
+        prefix: string;
+        nat?: {
+            staticPrefix?: string | null;
+        } | null;
+    }[] | null;
+    /** Identifier */
+    siteId?: string | null;
+    /** If the site is not configured in high availability mode, this configuration is optional (if omitted, use DHCP). However, if in high availability mode, static_address is required along with secondary a */
+    staticAddressing?: {
+        address: string;
+        dhcpRelay?: {
+            serverAddresses?: string[] | null;
+        } | null;
+        dhcpServer?: {
+            dhcpPoolEnd?: string | null;
+            dhcpPoolStart?: string | null;
+            dnsServer?: string | null;
+            dnsServers?: string[] | null;
+            reservations?: Record<string, unknown> | null;
+        } | null;
+        secondaryAddress?: string | null;
+        virtualAddress?: string | null;
+    } | null;
+    /** VLAN ID. Use zero for untagged. */
+    vlanTag?: number | null;
+}
+export declare const GetSiteLanResponse: Schema.Schema<GetSiteLanResponse>;
+export type GetSiteLanError = DefaultErrors;
+export declare const getSiteLan: API.OperationMethod<GetSiteLanRequest, GetSiteLanResponse, GetSiteLanError, Credentials | HttpClient.HttpClient>;
+export interface ListSiteLansRequest {
+    siteId: string;
+    /** Identifier */
+    accountId: string;
+}
+export declare const ListSiteLansRequest: Schema.Schema<ListSiteLansRequest>;
+export type ListSiteLansResponse = {
+    id?: string | null;
+    haLink?: boolean | null;
+    name?: string | null;
+    nat?: {
+        staticPrefix?: string | null;
+    } | null;
+    physport?: number | null;
+    routedSubnets?: {
+        nextHop: string;
+        prefix: string;
+        nat?: {
+            staticPrefix?: string | null;
+        } | null;
+    }[] | null;
+    siteId?: string | null;
+    staticAddressing?: {
+        address: string;
+        dhcpRelay?: {
+            serverAddresses?: string[] | null;
+        } | null;
+        dhcpServer?: {
+            dhcpPoolEnd?: string | null;
+            dhcpPoolStart?: string | null;
+            dnsServer?: string | null;
+            dnsServers?: string[] | null;
+            reservations?: Record<string, unknown> | null;
+        } | null;
+        secondaryAddress?: string | null;
+        virtualAddress?: string | null;
+    } | null;
+    vlanTag?: number | null;
+}[];
+export declare const ListSiteLansResponse: Schema.Schema<ListSiteLansResponse>;
+export type ListSiteLansError = DefaultErrors;
+export declare const listSiteLans: API.OperationMethod<ListSiteLansRequest, ListSiteLansResponse, ListSiteLansError, Credentials | HttpClient.HttpClient>;
+export interface CreateSiteLanRequest {
+    siteId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Body param: */
+    physport: number;
+    /** Body param: mark true to use this LAN for HA probing. only works for site with HA turned on. only one LAN can be set as the ha_link. */
+    haLink?: boolean;
+    /** Body param: */
+    name?: string;
+    /** Body param: */
+    nat?: {
+        staticPrefix?: string;
+    };
+    /** Body param: */
+    routedSubnets?: {
+        nextHop: string;
+        prefix: string;
+        nat?: {
+            staticPrefix?: string;
+        };
+    }[];
+    /** Body param: If the site is not configured in high availability mode, this configuration is optional (if omitted, use DHCP). However, if in high availability mode, static_address is required along with */
+    staticAddressing?: {
+        address: string;
+        dhcpRelay?: {
+            serverAddresses?: string[];
+        };
+        dhcpServer?: {
+            dhcpPoolEnd?: string;
+            dhcpPoolStart?: string;
+            dnsServer?: string;
+            dnsServers?: string[];
+            reservations?: Record<string, unknown>;
+        };
+        secondaryAddress?: string;
+        virtualAddress?: string;
+    };
+    /** Body param: VLAN ID. Use zero for untagged. */
+    vlanTag?: number;
+}
+export declare const CreateSiteLanRequest: Schema.Schema<CreateSiteLanRequest>;
+export type CreateSiteLanResponse = {
+    id?: string | null;
+    haLink?: boolean | null;
+    name?: string | null;
+    nat?: {
+        staticPrefix?: string | null;
+    } | null;
+    physport?: number | null;
+    routedSubnets?: {
+        nextHop: string;
+        prefix: string;
+        nat?: {
+            staticPrefix?: string | null;
+        } | null;
+    }[] | null;
+    siteId?: string | null;
+    staticAddressing?: {
+        address: string;
+        dhcpRelay?: {
+            serverAddresses?: string[] | null;
+        } | null;
+        dhcpServer?: {
+            dhcpPoolEnd?: string | null;
+            dhcpPoolStart?: string | null;
+            dnsServer?: string | null;
+            dnsServers?: string[] | null;
+            reservations?: Record<string, unknown> | null;
+        } | null;
+        secondaryAddress?: string | null;
+        virtualAddress?: string | null;
+    } | null;
+    vlanTag?: number | null;
+}[];
+export declare const CreateSiteLanResponse: Schema.Schema<CreateSiteLanResponse>;
+export type CreateSiteLanError = DefaultErrors;
+export declare const createSiteLan: API.OperationMethod<CreateSiteLanRequest, CreateSiteLanResponse, CreateSiteLanError, Credentials | HttpClient.HttpClient>;
+export interface UpdateSiteLanRequest {
+    siteId: string;
+    lanId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Body param: */
+    name?: string;
+    /** Body param: */
+    nat?: {
+        staticPrefix?: string;
+    };
+    /** Body param: */
+    physport?: number;
+    /** Body param: */
+    routedSubnets?: {
+        nextHop: string;
+        prefix: string;
+        nat?: {
+            staticPrefix?: string;
+        };
+    }[];
+    /** Body param: If the site is not configured in high availability mode, this configuration is optional (if omitted, use DHCP). However, if in high availability mode, static_address is required along with */
+    staticAddressing?: {
+        address: string;
+        dhcpRelay?: {
+            serverAddresses?: string[];
+        };
+        dhcpServer?: {
+            dhcpPoolEnd?: string;
+            dhcpPoolStart?: string;
+            dnsServer?: string;
+            dnsServers?: string[];
+            reservations?: Record<string, unknown>;
+        };
+        secondaryAddress?: string;
+        virtualAddress?: string;
+    };
+    /** Body param: VLAN ID. Use zero for untagged. */
+    vlanTag?: number;
+}
+export declare const UpdateSiteLanRequest: Schema.Schema<UpdateSiteLanRequest>;
+export interface UpdateSiteLanResponse {
+    /** Identifier */
+    id?: string | null;
+    /** mark true to use this LAN for HA probing. only works for site with HA turned on. only one LAN can be set as the ha_link. */
+    haLink?: boolean | null;
+    name?: string | null;
+    nat?: {
+        staticPrefix?: string | null;
+    } | null;
+    physport?: number | null;
+    routedSubnets?: {
+        nextHop: string;
+        prefix: string;
+        nat?: {
+            staticPrefix?: string | null;
+        } | null;
+    }[] | null;
+    /** Identifier */
+    siteId?: string | null;
+    /** If the site is not configured in high availability mode, this configuration is optional (if omitted, use DHCP). However, if in high availability mode, static_address is required along with secondary a */
+    staticAddressing?: {
+        address: string;
+        dhcpRelay?: {
+            serverAddresses?: string[] | null;
+        } | null;
+        dhcpServer?: {
+            dhcpPoolEnd?: string | null;
+            dhcpPoolStart?: string | null;
+            dnsServer?: string | null;
+            dnsServers?: string[] | null;
+            reservations?: Record<string, unknown> | null;
+        } | null;
+        secondaryAddress?: string | null;
+        virtualAddress?: string | null;
+    } | null;
+    /** VLAN ID. Use zero for untagged. */
+    vlanTag?: number | null;
+}
+export declare const UpdateSiteLanResponse: Schema.Schema<UpdateSiteLanResponse>;
+export type UpdateSiteLanError = DefaultErrors;
+export declare const updateSiteLan: API.OperationMethod<UpdateSiteLanRequest, UpdateSiteLanResponse, UpdateSiteLanError, Credentials | HttpClient.HttpClient>;
+export interface PatchSiteLanRequest {
+    siteId: string;
+    lanId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Body param: */
+    name?: string;
+    /** Body param: */
+    nat?: {
+        staticPrefix?: string;
+    };
+    /** Body param: */
+    physport?: number;
+    /** Body param: */
+    routedSubnets?: {
+        nextHop: string;
+        prefix: string;
+        nat?: {
+            staticPrefix?: string;
+        };
+    }[];
+    /** Body param: If the site is not configured in high availability mode, this configuration is optional (if omitted, use DHCP). However, if in high availability mode, static_address is required along with */
+    staticAddressing?: {
+        address: string;
+        dhcpRelay?: {
+            serverAddresses?: string[];
+        };
+        dhcpServer?: {
+            dhcpPoolEnd?: string;
+            dhcpPoolStart?: string;
+            dnsServer?: string;
+            dnsServers?: string[];
+            reservations?: Record<string, unknown>;
+        };
+        secondaryAddress?: string;
+        virtualAddress?: string;
+    };
+    /** Body param: VLAN ID. Use zero for untagged. */
+    vlanTag?: number;
+}
+export declare const PatchSiteLanRequest: Schema.Schema<PatchSiteLanRequest>;
+export interface PatchSiteLanResponse {
+    /** Identifier */
+    id?: string | null;
+    /** mark true to use this LAN for HA probing. only works for site with HA turned on. only one LAN can be set as the ha_link. */
+    haLink?: boolean | null;
+    name?: string | null;
+    nat?: {
+        staticPrefix?: string | null;
+    } | null;
+    physport?: number | null;
+    routedSubnets?: {
+        nextHop: string;
+        prefix: string;
+        nat?: {
+            staticPrefix?: string | null;
+        } | null;
+    }[] | null;
+    /** Identifier */
+    siteId?: string | null;
+    /** If the site is not configured in high availability mode, this configuration is optional (if omitted, use DHCP). However, if in high availability mode, static_address is required along with secondary a */
+    staticAddressing?: {
+        address: string;
+        dhcpRelay?: {
+            serverAddresses?: string[] | null;
+        } | null;
+        dhcpServer?: {
+            dhcpPoolEnd?: string | null;
+            dhcpPoolStart?: string | null;
+            dnsServer?: string | null;
+            dnsServers?: string[] | null;
+            reservations?: Record<string, unknown> | null;
+        } | null;
+        secondaryAddress?: string | null;
+        virtualAddress?: string | null;
+    } | null;
+    /** VLAN ID. Use zero for untagged. */
+    vlanTag?: number | null;
+}
+export declare const PatchSiteLanResponse: Schema.Schema<PatchSiteLanResponse>;
+export type PatchSiteLanError = DefaultErrors;
+export declare const patchSiteLan: API.OperationMethod<PatchSiteLanRequest, PatchSiteLanResponse, PatchSiteLanError, Credentials | HttpClient.HttpClient>;
+export interface DeleteSiteLanRequest {
+    siteId: string;
+    lanId: string;
+    /** Identifier */
+    accountId: string;
+}
+export declare const DeleteSiteLanRequest: Schema.Schema<DeleteSiteLanRequest>;
+export interface DeleteSiteLanResponse {
+    /** Identifier */
+    id?: string | null;
+    /** mark true to use this LAN for HA probing. only works for site with HA turned on. only one LAN can be set as the ha_link. */
+    haLink?: boolean | null;
+    name?: string | null;
+    nat?: {
+        staticPrefix?: string | null;
+    } | null;
+    physport?: number | null;
+    routedSubnets?: {
+        nextHop: string;
+        prefix: string;
+        nat?: {
+            staticPrefix?: string | null;
+        } | null;
+    }[] | null;
+    /** Identifier */
+    siteId?: string | null;
+    /** If the site is not configured in high availability mode, this configuration is optional (if omitted, use DHCP). However, if in high availability mode, static_address is required along with secondary a */
+    staticAddressing?: {
+        address: string;
+        dhcpRelay?: {
+            serverAddresses?: string[] | null;
+        } | null;
+        dhcpServer?: {
+            dhcpPoolEnd?: string | null;
+            dhcpPoolStart?: string | null;
+            dnsServer?: string | null;
+            dnsServers?: string[] | null;
+            reservations?: Record<string, unknown> | null;
+        } | null;
+        secondaryAddress?: string | null;
+        virtualAddress?: string | null;
+    } | null;
+    /** VLAN ID. Use zero for untagged. */
+    vlanTag?: number | null;
+}
+export declare const DeleteSiteLanResponse: Schema.Schema<DeleteSiteLanResponse>;
+export type DeleteSiteLanError = DefaultErrors;
+export declare const deleteSiteLan: API.OperationMethod<DeleteSiteLanRequest, DeleteSiteLanResponse, DeleteSiteLanError, Credentials | HttpClient.HttpClient>;
+export interface GetSiteWanRequest {
+    siteId: string;
+    wanId: string;
+    /** Identifier */
+    accountId: string;
+}
+export declare const GetSiteWanRequest: Schema.Schema<GetSiteWanRequest>;
+export interface GetSiteWanResponse {
+    /** Identifier */
+    id?: string | null;
+    /** Magic WAN health check rate for tunnels created on this link. The default value is `mid`. */
+    healthCheckRate?: "low" | "mid" | "high" | null;
+    name?: string | null;
+    physport?: number | null;
+    /** Priority of WAN for traffic loadbalancing. */
+    priority?: number | null;
+    /** Identifier */
+    siteId?: string | null;
+    /** (optional) if omitted, use DHCP. Submit secondary_address when site is in high availability mode. */
+    staticAddressing?: {
+        address: string;
+        gatewayAddress: string;
+        secondaryAddress?: string | null;
+    } | null;
+    /** VLAN ID. Use zero for untagged. */
+    vlanTag?: number | null;
+}
+export declare const GetSiteWanResponse: Schema.Schema<GetSiteWanResponse>;
+export type GetSiteWanError = DefaultErrors;
+export declare const getSiteWan: API.OperationMethod<GetSiteWanRequest, GetSiteWanResponse, GetSiteWanError, Credentials | HttpClient.HttpClient>;
+export interface ListSiteWansRequest {
+    siteId: string;
+    /** Identifier */
+    accountId: string;
+}
+export declare const ListSiteWansRequest: Schema.Schema<ListSiteWansRequest>;
+export type ListSiteWansResponse = {
+    id?: string | null;
+    healthCheckRate?: "low" | "mid" | "high" | null;
+    name?: string | null;
+    physport?: number | null;
+    priority?: number | null;
+    siteId?: string | null;
+    staticAddressing?: {
+        address: string;
+        gatewayAddress: string;
+        secondaryAddress?: string | null;
+    } | null;
+    vlanTag?: number | null;
+}[];
+export declare const ListSiteWansResponse: Schema.Schema<ListSiteWansResponse>;
+export type ListSiteWansError = DefaultErrors;
+export declare const listSiteWans: API.OperationMethod<ListSiteWansRequest, ListSiteWansResponse, ListSiteWansError, Credentials | HttpClient.HttpClient>;
+export interface CreateSiteWanRequest {
+    siteId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Body param: */
+    physport: number;
+    /** Body param: */
+    name?: string;
+    /** Body param: */
+    priority?: number;
+    /** Body param: (optional) if omitted, use DHCP. Submit secondary_address when site is in high availability mode. */
+    staticAddressing?: {
+        address: string;
+        gatewayAddress: string;
+        secondaryAddress?: string;
+    };
+    /** Body param: VLAN ID. Use zero for untagged. */
+    vlanTag?: number;
+}
+export declare const CreateSiteWanRequest: Schema.Schema<CreateSiteWanRequest>;
+export type CreateSiteWanResponse = {
+    id?: string | null;
+    healthCheckRate?: "low" | "mid" | "high" | null;
+    name?: string | null;
+    physport?: number | null;
+    priority?: number | null;
+    siteId?: string | null;
+    staticAddressing?: {
+        address: string;
+        gatewayAddress: string;
+        secondaryAddress?: string | null;
+    } | null;
+    vlanTag?: number | null;
+}[];
+export declare const CreateSiteWanResponse: Schema.Schema<CreateSiteWanResponse>;
+export type CreateSiteWanError = DefaultErrors;
+export declare const createSiteWan: API.OperationMethod<CreateSiteWanRequest, CreateSiteWanResponse, CreateSiteWanError, Credentials | HttpClient.HttpClient>;
+export interface UpdateSiteWanRequest {
+    siteId: string;
+    wanId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Body param: */
+    name?: string;
+    /** Body param: */
+    physport?: number;
+    /** Body param: */
+    priority?: number;
+    /** Body param: (optional) if omitted, use DHCP. Submit secondary_address when site is in high availability mode. */
+    staticAddressing?: {
+        address: string;
+        gatewayAddress: string;
+        secondaryAddress?: string;
+    };
+    /** Body param: VLAN ID. Use zero for untagged. */
+    vlanTag?: number;
+}
+export declare const UpdateSiteWanRequest: Schema.Schema<UpdateSiteWanRequest>;
+export interface UpdateSiteWanResponse {
+    /** Identifier */
+    id?: string | null;
+    /** Magic WAN health check rate for tunnels created on this link. The default value is `mid`. */
+    healthCheckRate?: "low" | "mid" | "high" | null;
+    name?: string | null;
+    physport?: number | null;
+    /** Priority of WAN for traffic loadbalancing. */
+    priority?: number | null;
+    /** Identifier */
+    siteId?: string | null;
+    /** (optional) if omitted, use DHCP. Submit secondary_address when site is in high availability mode. */
+    staticAddressing?: {
+        address: string;
+        gatewayAddress: string;
+        secondaryAddress?: string | null;
+    } | null;
+    /** VLAN ID. Use zero for untagged. */
+    vlanTag?: number | null;
+}
+export declare const UpdateSiteWanResponse: Schema.Schema<UpdateSiteWanResponse>;
+export type UpdateSiteWanError = DefaultErrors;
+export declare const updateSiteWan: API.OperationMethod<UpdateSiteWanRequest, UpdateSiteWanResponse, UpdateSiteWanError, Credentials | HttpClient.HttpClient>;
+export interface PatchSiteWanRequest {
+    siteId: string;
+    wanId: string;
+    /** Path param: Identifier */
+    accountId: string;
+    /** Body param: */
+    name?: string;
+    /** Body param: */
+    physport?: number;
+    /** Body param: */
+    priority?: number;
+    /** Body param: (optional) if omitted, use DHCP. Submit secondary_address when site is in high availability mode. */
+    staticAddressing?: {
+        address: string;
+        gatewayAddress: string;
+        secondaryAddress?: string;
+    };
+    /** Body param: VLAN ID. Use zero for untagged. */
+    vlanTag?: number;
+}
+export declare const PatchSiteWanRequest: Schema.Schema<PatchSiteWanRequest>;
+export interface PatchSiteWanResponse {
+    /** Identifier */
+    id?: string | null;
+    /** Magic WAN health check rate for tunnels created on this link. The default value is `mid`. */
+    healthCheckRate?: "low" | "mid" | "high" | null;
+    name?: string | null;
+    physport?: number | null;
+    /** Priority of WAN for traffic loadbalancing. */
+    priority?: number | null;
+    /** Identifier */
+    siteId?: string | null;
+    /** (optional) if omitted, use DHCP. Submit secondary_address when site is in high availability mode. */
+    staticAddressing?: {
+        address: string;
+        gatewayAddress: string;
+        secondaryAddress?: string | null;
+    } | null;
+    /** VLAN ID. Use zero for untagged. */
+    vlanTag?: number | null;
+}
+export declare const PatchSiteWanResponse: Schema.Schema<PatchSiteWanResponse>;
+export type PatchSiteWanError = DefaultErrors;
+export declare const patchSiteWan: API.OperationMethod<PatchSiteWanRequest, PatchSiteWanResponse, PatchSiteWanError, Credentials | HttpClient.HttpClient>;
+export interface DeleteSiteWanRequest {
+    siteId: string;
+    wanId: string;
+    /** Identifier */
+    accountId: string;
+}
+export declare const DeleteSiteWanRequest: Schema.Schema<DeleteSiteWanRequest>;
+export interface DeleteSiteWanResponse {
+    /** Identifier */
+    id?: string | null;
+    /** Magic WAN health check rate for tunnels created on this link. The default value is `mid`. */
+    healthCheckRate?: "low" | "mid" | "high" | null;
+    name?: string | null;
+    physport?: number | null;
+    /** Priority of WAN for traffic loadbalancing. */
+    priority?: number | null;
+    /** Identifier */
+    siteId?: string | null;
+    /** (optional) if omitted, use DHCP. Submit secondary_address when site is in high availability mode. */
+    staticAddressing?: {
+        address: string;
+        gatewayAddress: string;
+        secondaryAddress?: string | null;
+    } | null;
+    /** VLAN ID. Use zero for untagged. */
+    vlanTag?: number | null;
+}
+export declare const DeleteSiteWanResponse: Schema.Schema<DeleteSiteWanResponse>;
+export type DeleteSiteWanError = DefaultErrors;
+export declare const deleteSiteWan: API.OperationMethod<DeleteSiteWanRequest, DeleteSiteWanResponse, DeleteSiteWanError, Credentials | HttpClient.HttpClient>;
+//# sourceMappingURL=magic-transit.d.ts.map