import * as Core from 'cloudflare/core';
import { APIResource } from 'cloudflare/resource';
import * as LansAPI from 'cloudflare/resources/magic-transit/sites/lans';
export declare class Lans extends APIResource {
    /**
     * Creates a new LAN. If the site is in high availability mode, static_addressing
     * is required along with secondary and virtual address.
     */
    create(accountIdentifier: string, siteIdentifier: string, body: LanCreateParams, options?: Core.RequestOptions): Core.APIPromise<LanCreateResponse>;
    /**
     * Update a specific LAN.
     */
    update(accountIdentifier: string, siteIdentifier: string, lanIdentifier: string, body: LanUpdateParams, options?: Core.RequestOptions): Core.APIPromise<LanUpdateResponse>;
    /**
     * Lists LANs associated with an account and site.
     */
    list(accountIdentifier: string, siteIdentifier: string, options?: Core.RequestOptions): Core.APIPromise<LanListResponse>;
    /**
     * Remove a specific LAN.
     */
    delete(accountIdentifier: string, siteIdentifier: string, lanIdentifier: string, options?: Core.RequestOptions): Core.APIPromise<LanDeleteResponse>;
    /**
     * Get a specific LAN.
     */
    get(accountIdentifier: string, siteIdentifier: string, lanIdentifier: string, options?: Core.RequestOptions): Core.APIPromise<LanGetResponse>;
}
export interface LanCreateResponse {
    lans?: Array<LanCreateResponse.Lan>;
}
export declare namespace LanCreateResponse {
    interface Lan {
        /**
         * Identifier
         */
        id?: string;
        description?: string;
        /**
         * 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.
         */
        ha_link?: boolean;
        nat?: Lan.Nat;
        physport?: number;
        routed_subnets?: Array<Lan.RoutedSubnet>;
        /**
         * Identifier
         */
        site_id?: string;
        /**
         * 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 and virtual address.
         */
        static_addressing?: Lan.StaticAddressing;
        /**
         * VLAN port number.
         */
        vlan_tag?: number;
    }
    namespace Lan {
        interface Nat {
            /**
             * A valid CIDR notation representing an IP range.
             */
            static_prefix?: string;
        }
        interface RoutedSubnet {
            /**
             * A valid IPv4 address.
             */
            next_hop: string;
            /**
             * A valid CIDR notation representing an IP range.
             */
            prefix: string;
            nat?: RoutedSubnet.Nat;
        }
        namespace RoutedSubnet {
            interface Nat {
                /**
                 * A valid CIDR notation representing an IP range.
                 */
                static_prefix?: string;
            }
        }
        /**
         * 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 and virtual address.
         */
        interface StaticAddressing {
            /**
             * A valid CIDR notation representing an IP range.
             */
            address: string;
            dhcp_relay?: StaticAddressing.DhcpRelay;
            dhcp_server?: StaticAddressing.DhcpServer;
            /**
             * A valid CIDR notation representing an IP range.
             */
            secondary_address?: string;
            /**
             * A valid CIDR notation representing an IP range.
             */
            virtual_address?: string;
        }
        namespace StaticAddressing {
            interface DhcpRelay {
                /**
                 * List of DHCP server IPs.
                 */
                server_addresses?: Array<string>;
            }
            interface DhcpServer {
                /**
                 * A valid IPv4 address.
                 */
                dhcp_pool_end?: string;
                /**
                 * A valid IPv4 address.
                 */
                dhcp_pool_start?: string;
                /**
                 * A valid IPv4 address.
                 */
                dns_server?: string;
                /**
                 * Mapping of MAC addresses to IP addresses
                 */
                reservations?: Record<string, string>;
            }
        }
    }
}
export interface LanUpdateResponse {
    lan?: LanUpdateResponse.Lan;
}
export declare namespace LanUpdateResponse {
    interface Lan {
        /**
         * Identifier
         */
        id?: string;
        description?: string;
        /**
         * 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.
         */
        ha_link?: boolean;
        nat?: Lan.Nat;
        physport?: number;
        routed_subnets?: Array<Lan.RoutedSubnet>;
        /**
         * Identifier
         */
        site_id?: string;
        /**
         * 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 and virtual address.
         */
        static_addressing?: Lan.StaticAddressing;
        /**
         * VLAN port number.
         */
        vlan_tag?: number;
    }
    namespace Lan {
        interface Nat {
            /**
             * A valid CIDR notation representing an IP range.
             */
            static_prefix?: string;
        }
        interface RoutedSubnet {
            /**
             * A valid IPv4 address.
             */
            next_hop: string;
            /**
             * A valid CIDR notation representing an IP range.
             */
            prefix: string;
            nat?: RoutedSubnet.Nat;
        }
        namespace RoutedSubnet {
            interface Nat {
                /**
                 * A valid CIDR notation representing an IP range.
                 */
                static_prefix?: string;
            }
        }
        /**
         * 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 and virtual address.
         */
        interface StaticAddressing {
            /**
             * A valid CIDR notation representing an IP range.
             */
            address: string;
            dhcp_relay?: StaticAddressing.DhcpRelay;
            dhcp_server?: StaticAddressing.DhcpServer;
            /**
             * A valid CIDR notation representing an IP range.
             */
            secondary_address?: string;
            /**
             * A valid CIDR notation representing an IP range.
             */
            virtual_address?: string;
        }
        namespace StaticAddressing {
            interface DhcpRelay {
                /**
                 * List of DHCP server IPs.
                 */
                server_addresses?: Array<string>;
            }
            interface DhcpServer {
                /**
                 * A valid IPv4 address.
                 */
                dhcp_pool_end?: string;
                /**
                 * A valid IPv4 address.
                 */
                dhcp_pool_start?: string;
                /**
                 * A valid IPv4 address.
                 */
                dns_server?: string;
                /**
                 * Mapping of MAC addresses to IP addresses
                 */
                reservations?: Record<string, string>;
            }
        }
    }
}
export interface LanListResponse {
    lans?: Array<LanListResponse.Lan>;
}
export declare namespace LanListResponse {
    interface Lan {
        /**
         * Identifier
         */
        id?: string;
        description?: string;
        /**
         * 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.
         */
        ha_link?: boolean;
        nat?: Lan.Nat;
        physport?: number;
        routed_subnets?: Array<Lan.RoutedSubnet>;
        /**
         * Identifier
         */
        site_id?: string;
        /**
         * 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 and virtual address.
         */
        static_addressing?: Lan.StaticAddressing;
        /**
         * VLAN port number.
         */
        vlan_tag?: number;
    }
    namespace Lan {
        interface Nat {
            /**
             * A valid CIDR notation representing an IP range.
             */
            static_prefix?: string;
        }
        interface RoutedSubnet {
            /**
             * A valid IPv4 address.
             */
            next_hop: string;
            /**
             * A valid CIDR notation representing an IP range.
             */
            prefix: string;
            nat?: RoutedSubnet.Nat;
        }
        namespace RoutedSubnet {
            interface Nat {
                /**
                 * A valid CIDR notation representing an IP range.
                 */
                static_prefix?: string;
            }
        }
        /**
         * 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 and virtual address.
         */
        interface StaticAddressing {
            /**
             * A valid CIDR notation representing an IP range.
             */
            address: string;
            dhcp_relay?: StaticAddressing.DhcpRelay;
            dhcp_server?: StaticAddressing.DhcpServer;
            /**
             * A valid CIDR notation representing an IP range.
             */
            secondary_address?: string;
            /**
             * A valid CIDR notation representing an IP range.
             */
            virtual_address?: string;
        }
        namespace StaticAddressing {
            interface DhcpRelay {
                /**
                 * List of DHCP server IPs.
                 */
                server_addresses?: Array<string>;
            }
            interface DhcpServer {
                /**
                 * A valid IPv4 address.
                 */
                dhcp_pool_end?: string;
                /**
                 * A valid IPv4 address.
                 */
                dhcp_pool_start?: string;
                /**
                 * A valid IPv4 address.
                 */
                dns_server?: string;
                /**
                 * Mapping of MAC addresses to IP addresses
                 */
                reservations?: Record<string, string>;
            }
        }
    }
}
export interface LanDeleteResponse {
    deleted?: boolean;
    deleted_lan?: LanDeleteResponse.DeletedLan;
}
export declare namespace LanDeleteResponse {
    interface DeletedLan {
        /**
         * Identifier
         */
        id?: string;
        description?: string;
        /**
         * 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.
         */
        ha_link?: boolean;
        nat?: DeletedLan.Nat;
        physport?: number;
        routed_subnets?: Array<DeletedLan.RoutedSubnet>;
        /**
         * Identifier
         */
        site_id?: string;
        /**
         * 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 and virtual address.
         */
        static_addressing?: DeletedLan.StaticAddressing;
        /**
         * VLAN port number.
         */
        vlan_tag?: number;
    }
    namespace DeletedLan {
        interface Nat {
            /**
             * A valid CIDR notation representing an IP range.
             */
            static_prefix?: string;
        }
        interface RoutedSubnet {
            /**
             * A valid IPv4 address.
             */
            next_hop: string;
            /**
             * A valid CIDR notation representing an IP range.
             */
            prefix: string;
            nat?: RoutedSubnet.Nat;
        }
        namespace RoutedSubnet {
            interface Nat {
                /**
                 * A valid CIDR notation representing an IP range.
                 */
                static_prefix?: string;
            }
        }
        /**
         * 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 and virtual address.
         */
        interface StaticAddressing {
            /**
             * A valid CIDR notation representing an IP range.
             */
            address: string;
            dhcp_relay?: StaticAddressing.DhcpRelay;
            dhcp_server?: StaticAddressing.DhcpServer;
            /**
             * A valid CIDR notation representing an IP range.
             */
            secondary_address?: string;
            /**
             * A valid CIDR notation representing an IP range.
             */
            virtual_address?: string;
        }
        namespace StaticAddressing {
            interface DhcpRelay {
                /**
                 * List of DHCP server IPs.
                 */
                server_addresses?: Array<string>;
            }
            interface DhcpServer {
                /**
                 * A valid IPv4 address.
                 */
                dhcp_pool_end?: string;
                /**
                 * A valid IPv4 address.
                 */
                dhcp_pool_start?: string;
                /**
                 * A valid IPv4 address.
                 */
                dns_server?: string;
                /**
                 * Mapping of MAC addresses to IP addresses
                 */
                reservations?: Record<string, string>;
            }
        }
    }
}
export interface LanGetResponse {
    lan?: LanGetResponse.Lan;
}
export declare namespace LanGetResponse {
    interface Lan {
        /**
         * Identifier
         */
        id?: string;
        description?: string;
        /**
         * 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.
         */
        ha_link?: boolean;
        nat?: Lan.Nat;
        physport?: number;
        routed_subnets?: Array<Lan.RoutedSubnet>;
        /**
         * Identifier
         */
        site_id?: string;
        /**
         * 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 and virtual address.
         */
        static_addressing?: Lan.StaticAddressing;
        /**
         * VLAN port number.
         */
        vlan_tag?: number;
    }
    namespace Lan {
        interface Nat {
            /**
             * A valid CIDR notation representing an IP range.
             */
            static_prefix?: string;
        }
        interface RoutedSubnet {
            /**
             * A valid IPv4 address.
             */
            next_hop: string;
            /**
             * A valid CIDR notation representing an IP range.
             */
            prefix: string;
            nat?: RoutedSubnet.Nat;
        }
        namespace RoutedSubnet {
            interface Nat {
                /**
                 * A valid CIDR notation representing an IP range.
                 */
                static_prefix?: string;
            }
        }
        /**
         * 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 and virtual address.
         */
        interface StaticAddressing {
            /**
             * A valid CIDR notation representing an IP range.
             */
            address: string;
            dhcp_relay?: StaticAddressing.DhcpRelay;
            dhcp_server?: StaticAddressing.DhcpServer;
            /**
             * A valid CIDR notation representing an IP range.
             */
            secondary_address?: string;
            /**
             * A valid CIDR notation representing an IP range.
             */
            virtual_address?: string;
        }
        namespace StaticAddressing {
            interface DhcpRelay {
                /**
                 * List of DHCP server IPs.
                 */
                server_addresses?: Array<string>;
            }
            interface DhcpServer {
                /**
                 * A valid IPv4 address.
                 */
                dhcp_pool_end?: string;
                /**
                 * A valid IPv4 address.
                 */
                dhcp_pool_start?: string;
                /**
                 * A valid IPv4 address.
                 */
                dns_server?: string;
                /**
                 * Mapping of MAC addresses to IP addresses
                 */
                reservations?: Record<string, string>;
            }
        }
    }
}
export interface LanCreateParams {
    lan?: LanCreateParams.Lan;
}
export declare namespace LanCreateParams {
    interface Lan {
        physport: number;
        /**
         * VLAN port number.
         */
        vlan_tag: number;
        description?: string;
        /**
         * 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.
         */
        ha_link?: boolean;
        nat?: Lan.Nat;
        routed_subnets?: Array<Lan.RoutedSubnet>;
        /**
         * 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 and virtual address.
         */
        static_addressing?: Lan.StaticAddressing;
    }
    namespace Lan {
        interface Nat {
            /**
             * A valid CIDR notation representing an IP range.
             */
            static_prefix?: string;
        }
        interface RoutedSubnet {
            /**
             * A valid IPv4 address.
             */
            next_hop: string;
            /**
             * A valid CIDR notation representing an IP range.
             */
            prefix: string;
            nat?: RoutedSubnet.Nat;
        }
        namespace RoutedSubnet {
            interface Nat {
                /**
                 * A valid CIDR notation representing an IP range.
                 */
                static_prefix?: string;
            }
        }
        /**
         * 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 and virtual address.
         */
        interface StaticAddressing {
            /**
             * A valid CIDR notation representing an IP range.
             */
            address: string;
            dhcp_relay?: StaticAddressing.DhcpRelay;
            dhcp_server?: StaticAddressing.DhcpServer;
            /**
             * A valid CIDR notation representing an IP range.
             */
            secondary_address?: string;
            /**
             * A valid CIDR notation representing an IP range.
             */
            virtual_address?: string;
        }
        namespace StaticAddressing {
            interface DhcpRelay {
                /**
                 * List of DHCP server IPs.
                 */
                server_addresses?: Array<string>;
            }
            interface DhcpServer {
                /**
                 * A valid IPv4 address.
                 */
                dhcp_pool_end?: string;
                /**
                 * A valid IPv4 address.
                 */
                dhcp_pool_start?: string;
                /**
                 * A valid IPv4 address.
                 */
                dns_server?: string;
                /**
                 * Mapping of MAC addresses to IP addresses
                 */
                reservations?: Record<string, string>;
            }
        }
    }
}
export interface LanUpdateParams {
    lan?: LanUpdateParams.Lan;
}
export declare namespace LanUpdateParams {
    interface Lan {
        description?: string;
        nat?: Lan.Nat;
        physport?: number;
        routed_subnets?: Array<Lan.RoutedSubnet>;
        /**
         * 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 and virtual address.
         */
        static_addressing?: Lan.StaticAddressing;
        /**
         * VLAN port number.
         */
        vlan_tag?: number;
    }
    namespace Lan {
        interface Nat {
            /**
             * A valid CIDR notation representing an IP range.
             */
            static_prefix?: string;
        }
        interface RoutedSubnet {
            /**
             * A valid IPv4 address.
             */
            next_hop: string;
            /**
             * A valid CIDR notation representing an IP range.
             */
            prefix: string;
            nat?: RoutedSubnet.Nat;
        }
        namespace RoutedSubnet {
            interface Nat {
                /**
                 * A valid CIDR notation representing an IP range.
                 */
                static_prefix?: string;
            }
        }
        /**
         * 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 and virtual address.
         */
        interface StaticAddressing {
            /**
             * A valid CIDR notation representing an IP range.
             */
            address: string;
            dhcp_relay?: StaticAddressing.DhcpRelay;
            dhcp_server?: StaticAddressing.DhcpServer;
            /**
             * A valid CIDR notation representing an IP range.
             */
            secondary_address?: string;
            /**
             * A valid CIDR notation representing an IP range.
             */
            virtual_address?: string;
        }
        namespace StaticAddressing {
            interface DhcpRelay {
                /**
                 * List of DHCP server IPs.
                 */
                server_addresses?: Array<string>;
            }
            interface DhcpServer {
                /**
                 * A valid IPv4 address.
                 */
                dhcp_pool_end?: string;
                /**
                 * A valid IPv4 address.
                 */
                dhcp_pool_start?: string;
                /**
                 * A valid IPv4 address.
                 */
                dns_server?: string;
                /**
                 * Mapping of MAC addresses to IP addresses
                 */
                reservations?: Record<string, string>;
            }
        }
    }
}
export declare namespace Lans {
    export import LanCreateResponse = LansAPI.LanCreateResponse;
    export import LanUpdateResponse = LansAPI.LanUpdateResponse;
    export import LanListResponse = LansAPI.LanListResponse;
    export import LanDeleteResponse = LansAPI.LanDeleteResponse;
    export import LanGetResponse = LansAPI.LanGetResponse;
    export import LanCreateParams = LansAPI.LanCreateParams;
    export import LanUpdateParams = LansAPI.LanUpdateParams;
}
//# sourceMappingURL=lans.d.ts.map