import { z } from 'zod';
/**
 * UniFi Network API Type Definitions
 *
 * Comprehensive TypeScript types for UniFi Network Application API,
 * supporting both legacy firewall and Zone-Based Firewall (ZBF) systems.
 */
export declare enum DeviceType {
    GATEWAY = "ugw",
    SWITCH = "usw",
    ACCESS_POINT = "uap",
    PROTECT = "protect",
    CAMERA = "camera",
    DOORBELL = "doorbell",
    SENSOR = "sensor"
}
export declare enum DeviceStatus {
    ONLINE = "online",
    OFFLINE = "offline",
    UPGRADING = "upgrading",
    PROVISIONING = "provisioning",
    ADOPTING = "adopting",
    HEARTBEAT_MISSED = "heartbeat_missed"
}
export declare enum ClientType {
    WIRED = "wired",
    WIRELESS = "wireless",
    VPN = "vpn"
}
export declare enum FirewallAction {
    ALLOW = "allow",
    DENY = "deny",
    REJECT = "reject",
    DROP = "drop"
}
export declare enum Protocol {
    TCP = "tcp",
    UDP = "udp",
    ICMP = "icmp",
    ANY = "any",
    ALL = "all"
}
export declare enum NetworkPurpose {
    CORPORATE = "corporate",
    GUEST = "guest",
    WAN = "wan",
    VLAN_ONLY = "vlan-only",
    VPN = "vpn"
}
export declare const UniFiConfigSchema: z.ZodObject<{
    gatewayIp: z.ZodString;
    apiKey: z.ZodString;
    siteId: z.ZodDefault<z.ZodString>;
    verifySSL: z.ZodDefault<z.ZodBoolean>;
    timeout: z.ZodDefault<z.ZodNumber>;
    maxRetries: z.ZodDefault<z.ZodNumber>;
    port: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    gatewayIp: string;
    apiKey: string;
    siteId: string;
    verifySSL: boolean;
    timeout: number;
    maxRetries: number;
    port?: number | undefined;
}, {
    gatewayIp: string;
    apiKey: string;
    siteId?: string | undefined;
    verifySSL?: boolean | undefined;
    timeout?: number | undefined;
    maxRetries?: number | undefined;
    port?: number | undefined;
}>;
export type UniFiConfig = z.infer<typeof UniFiConfigSchema>;
export interface AuthenticationHeaders {
    'X-API-KEY': string;
    'Content-Type': 'application/json';
    'Accept': 'application/json';
    [key: string]: string;
}
export interface SystemInfo {
    version: string;
    buildNumber: string;
    buildTimestamp: number;
    hostname: string;
    timezone: string;
    uptime: number;
    firewallMode: 'legacy' | 'zbf';
    zbfSupported: boolean;
    hardwareModel: string;
    hardwareRevision: string;
    ubntNetworkApplicationVersion: string;
}
export interface VersionInfo {
    version: string;
    supportsZBF: boolean;
    supportedFeatures: string[];
    deprecatedEndpoints: string[];
    newEndpoints: string[];
}
export declare const DeviceSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    type: z.ZodNativeEnum<typeof DeviceType>;
    model: z.ZodString;
    version: z.ZodString;
    status: z.ZodNativeEnum<typeof DeviceStatus>;
    ipAddress: z.ZodOptional<z.ZodString>;
    macAddress: z.ZodString;
    adopted: z.ZodBoolean;
    lastSeen: z.ZodDate;
    uptime: z.ZodOptional<z.ZodNumber>;
    bytes: z.ZodOptional<z.ZodNumber>;
    txBytes: z.ZodOptional<z.ZodNumber>;
    rxBytes: z.ZodOptional<z.ZodNumber>;
    totalBytes: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    type: DeviceType;
    status: DeviceStatus;
    id: string;
    name: string;
    model: string;
    version: string;
    macAddress: string;
    adopted: boolean;
    lastSeen: Date;
    ipAddress?: string | undefined;
    uptime?: number | undefined;
    bytes?: number | undefined;
    txBytes?: number | undefined;
    rxBytes?: number | undefined;
    totalBytes?: number | undefined;
}, {
    type: DeviceType;
    status: DeviceStatus;
    id: string;
    name: string;
    model: string;
    version: string;
    macAddress: string;
    adopted: boolean;
    lastSeen: Date;
    ipAddress?: string | undefined;
    uptime?: number | undefined;
    bytes?: number | undefined;
    txBytes?: number | undefined;
    rxBytes?: number | undefined;
    totalBytes?: number | undefined;
}>;
export type Device = z.infer<typeof DeviceSchema>;
export interface DeviceStats {
    cpuUsage: number;
    memoryUsage: number;
    temperature: number;
    uptime: number;
    bytesReceived: number;
    bytesTransmitted: number;
    packetsReceived: number;
    packetsTransmitted: number;
    lastUpdated: Date;
}
export interface DetailedDevice extends Device {
    serialNumber: string;
    firmwareVersion: string;
    configuredAt: Date;
    provisionedAt?: Date;
    connectedVia?: string;
    ports?: DevicePort[];
    radioTable?: RadioInfo[];
    stats?: DeviceStats;
}
export interface DevicePort {
    portIdx: number;
    name: string;
    enable: boolean;
    portPoe: boolean;
    poeMode: string;
    speed: number;
    fullDuplex: boolean;
    rxBytes: number;
    txBytes: number;
    rxPackets: number;
    txPackets: number;
}
export interface RadioInfo {
    name: string;
    radio: string;
    channel: number;
    ht: number;
    txPower: number;
    minRssi: number;
    maxRssi: number;
    nss: number;
}
export declare const ClientSchema: z.ZodObject<{
    id: z.ZodString;
    mac: z.ZodString;
    name: z.ZodOptional<z.ZodString>;
    hostname: z.ZodOptional<z.ZodString>;
    ip: z.ZodOptional<z.ZodString>;
    networkId: z.ZodString;
    deviceMac: z.ZodOptional<z.ZodString>;
    type: z.ZodNativeEnum<typeof ClientType>;
    connected: z.ZodBoolean;
    firstSeen: z.ZodDate;
    lastSeen: z.ZodDate;
    rxBytes: z.ZodNumber;
    txBytes: z.ZodNumber;
    blocked: z.ZodDefault<z.ZodBoolean>;
    noted: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    type: ClientType;
    id: string;
    lastSeen: Date;
    txBytes: number;
    rxBytes: number;
    mac: string;
    networkId: string;
    connected: boolean;
    firstSeen: Date;
    blocked: boolean;
    noted: boolean;
    name?: string | undefined;
    hostname?: string | undefined;
    ip?: string | undefined;
    deviceMac?: string | undefined;
}, {
    type: ClientType;
    id: string;
    lastSeen: Date;
    txBytes: number;
    rxBytes: number;
    mac: string;
    networkId: string;
    connected: boolean;
    firstSeen: Date;
    name?: string | undefined;
    hostname?: string | undefined;
    ip?: string | undefined;
    deviceMac?: string | undefined;
    blocked?: boolean | undefined;
    noted?: boolean | undefined;
}>;
export type Client = z.infer<typeof ClientSchema>;
export interface DetailedClient extends Client {
    oui: string;
    os: string;
    osName: string;
    deviceName: string;
    usergroup: string;
    use_fixedip: boolean;
    fixed_ip: string;
    network: string;
    essid?: string;
    channel?: number;
    radio?: string;
    signal?: number;
    noise?: number;
    rssi?: number;
    ccq?: number;
    satisfaction?: number;
    anomalies?: number;
    uptime?: number;
    txRate?: number;
    rxRate?: number;
    powersave_enabled?: boolean;
    is_11r?: boolean;
    user_id?: string;
    vlan?: number;
}
export declare const NetworkSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    purpose: z.ZodNativeEnum<typeof NetworkPurpose>;
    vlanId: z.ZodOptional<z.ZodNumber>;
    subnet: z.ZodString;
    gateway: z.ZodString;
    dhcpEnabled: z.ZodDefault<z.ZodBoolean>;
    dhcpRange: z.ZodOptional<z.ZodObject<{
        start: z.ZodString;
        end: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        start: string;
        end: string;
    }, {
        start: string;
        end: string;
    }>>;
    enabled: z.ZodDefault<z.ZodBoolean>;
    isNat: z.ZodDefault<z.ZodBoolean>;
    domainName: z.ZodOptional<z.ZodString>;
    networkGroup: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    id: string;
    name: string;
    purpose: NetworkPurpose;
    subnet: string;
    gateway: string;
    dhcpEnabled: boolean;
    enabled: boolean;
    isNat: boolean;
    vlanId?: number | undefined;
    dhcpRange?: {
        start: string;
        end: string;
    } | undefined;
    domainName?: string | undefined;
    networkGroup?: string | undefined;
}, {
    id: string;
    name: string;
    purpose: NetworkPurpose;
    subnet: string;
    gateway: string;
    vlanId?: number | undefined;
    dhcpEnabled?: boolean | undefined;
    dhcpRange?: {
        start: string;
        end: string;
    } | undefined;
    enabled?: boolean | undefined;
    isNat?: boolean | undefined;
    domainName?: string | undefined;
    networkGroup?: string | undefined;
}>;
export type Network = z.infer<typeof NetworkSchema>;
export interface DetailedNetwork extends Network {
    upProfile?: string;
    wanNetworkgroup?: string;
    wanType?: string;
    wanIp?: string;
    wanGateway?: string;
    wanDns1?: string;
    wanDns2?: string;
    wanUsername?: string;
    vpnType?: string;
    radiusProfile?: string;
    xWanPassword?: string;
    lteApn?: string;
    internetAccessEnabled?: boolean;
    intraNetworkAccessEnabled?: boolean;
    dhcpServerEnabled?: boolean;
    dhcpLeaseTime?: number;
    dhcpDns1?: string;
    dhcpDns2?: string;
    dhcpNtp?: string;
    dhcpLeasetime?: number;
    ipv6InterfaceType?: string;
    ipv6RaEnabled?: boolean;
    dhcpv6Enabled?: boolean;
}
export declare const FirewallRuleSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    enabled: z.ZodDefault<z.ZodBoolean>;
    action: z.ZodNativeEnum<typeof FirewallAction>;
    protocol: z.ZodNativeEnum<typeof Protocol>;
    src: z.ZodString;
    dst: z.ZodString;
    srcPort: z.ZodOptional<z.ZodString>;
    dstPort: z.ZodOptional<z.ZodString>;
    priority: z.ZodDefault<z.ZodNumber>;
    logging: z.ZodDefault<z.ZodBoolean>;
    state: z.ZodOptional<z.ZodEnum<["new", "established", "related", "invalid"]>>;
}, "strip", z.ZodTypeAny, {
    id: string;
    name: string;
    enabled: boolean;
    action: FirewallAction;
    protocol: Protocol;
    src: string;
    dst: string;
    priority: number;
    logging: boolean;
    srcPort?: string | undefined;
    dstPort?: string | undefined;
    state?: "new" | "established" | "related" | "invalid" | undefined;
}, {
    id: string;
    name: string;
    action: FirewallAction;
    protocol: Protocol;
    src: string;
    dst: string;
    enabled?: boolean | undefined;
    srcPort?: string | undefined;
    dstPort?: string | undefined;
    priority?: number | undefined;
    logging?: boolean | undefined;
    state?: "new" | "established" | "related" | "invalid" | undefined;
}>;
export type FirewallRule = z.infer<typeof FirewallRuleSchema>;
export interface DetailedFirewallRule extends FirewallRule {
    ruleIndex: number;
    ipsec: string;
    srcFirewallgroupIds: string[];
    dstFirewallgroupIds: string[];
    srcMacAddress: string;
    protocolMatchExcepted: boolean;
    icmpTypename: string;
    srcNetworkconfId: string;
    srcNetworkconfType: string;
    dstNetworkconfId: string;
    dstNetworkconfType: string;
    ruleSet: string;
}
export declare const FirewallZoneSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    predefined: z.ZodDefault<z.ZodBoolean>;
    networks: z.ZodArray<z.ZodString, "many">;
    interfaces: z.ZodArray<z.ZodString, "many">;
    enabled: z.ZodDefault<z.ZodBoolean>;
    localUser: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    id: string;
    name: string;
    enabled: boolean;
    predefined: boolean;
    networks: string[];
    interfaces: string[];
    localUser: boolean;
    description?: string | undefined;
}, {
    id: string;
    name: string;
    networks: string[];
    interfaces: string[];
    enabled?: boolean | undefined;
    description?: string | undefined;
    predefined?: boolean | undefined;
    localUser?: boolean | undefined;
}>;
export type FirewallZone = z.infer<typeof FirewallZoneSchema>;
export declare enum PredefinedZone {
    EXTERNAL = "external",
    INTERNAL = "internal",
    GATEWAY = "gateway",
    VPN = "vpn",
    HOTSPOT = "hotspot",
    DMZ = "dmz"
}
export declare const ZonePolicySchema: z.ZodObject<{
    id: z.ZodString;
    sourceZone: z.ZodString;
    targetZone: z.ZodString;
    action: z.ZodNativeEnum<typeof FirewallAction>;
    applications: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    ports: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    logging: z.ZodDefault<z.ZodBoolean>;
    enabled: z.ZodDefault<z.ZodBoolean>;
    priority: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    id: string;
    enabled: boolean;
    action: FirewallAction;
    priority: number;
    logging: boolean;
    sourceZone: string;
    targetZone: string;
    applications?: string[] | undefined;
    ports?: string[] | undefined;
}, {
    id: string;
    action: FirewallAction;
    sourceZone: string;
    targetZone: string;
    enabled?: boolean | undefined;
    priority?: number | undefined;
    logging?: boolean | undefined;
    applications?: string[] | undefined;
    ports?: string[] | undefined;
}>;
export type ZonePolicy = z.infer<typeof ZonePolicySchema>;
export interface ZonePolicyMatrix {
    zones: string[];
    policies: Record<string, Record<string, 'allow' | 'deny' | 'custom'>>;
}
export interface SimpleAppBlock {
    id: string;
    zoneId: string;
    appCategory: string;
    enabled: boolean;
    schedule?: {
        days: string[];
        startTime: string;
        endTime: string;
    };
}
export declare enum GroupType {
    ADDRESS_GROUP = "address-group",
    PORT_GROUP = "port-group",
    IPV6_ADDRESS_GROUP = "ipv6-address-group"
}
export declare const IPGroupSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    type: z.ZodNativeEnum<typeof GroupType>;
    members: z.ZodArray<z.ZodString, "many">;
    description: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    type: GroupType;
    id: string;
    name: string;
    members: string[];
    description?: string | undefined;
}, {
    type: GroupType;
    id: string;
    name: string;
    members: string[];
    description?: string | undefined;
}>;
export type IPGroup = z.infer<typeof IPGroupSchema>;
export interface SiteStats {
    totalDevices: number;
    onlineDevices: number;
    offlineDevices: number;
    totalClients: number;
    wiredClients: number;
    wirelessClients: number;
    guestClients: number;
    totalBytes: number;
    totalPackets: number;
    totalUptime: number;
    internetLatency: number;
    internetDropRate: number;
    lastUpdated: Date;
}
export interface BandwidthUsage {
    entityId: string;
    entityType: 'client' | 'device' | 'network';
    entityName: string;
    rxBytes: number;
    txBytes: number;
    rxRate: number;
    txRate: number;
    period: string;
    timestamp: Date;
}
export interface SystemEvent {
    id: string;
    timestamp: Date;
    type: string;
    severity: 'info' | 'warning' | 'error' | 'critical';
    message: string;
    deviceId?: string;
    clientId?: string;
    key: string;
    subsystem: string;
    details?: Record<string, any>;
}
export interface SystemAlert {
    id: string;
    timestamp: Date;
    type: string;
    severity: 'low' | 'medium' | 'high' | 'critical';
    message: string;
    acknowledged: boolean;
    deviceId?: string;
    source: string;
    details?: Record<string, any>;
}
export interface NetworkTopology {
    devices: Array<{
        id: string;
        name: string;
        type: DeviceType;
        connections: Array<{
            deviceId: string;
            port: string;
            linkSpeed: number;
        }>;
    }>;
    clients: Array<{
        id: string;
        connectedTo: string;
        connectionType: ClientType;
    }>;
}
export interface WiFiInterference {
    apId: string;
    apName: string;
    radio: string;
    channel: number;
    utilization: number;
    interference: number;
    neighbors: Array<{
        ssid: string;
        channel: number;
        signal: number;
    }>;
    timestamp: Date;
}
export interface ScheduleConfig {
    days: Array<'monday' | 'tuesday' | 'wednesday' | 'thursday' | 'friday' | 'saturday' | 'sunday'>;
    startTime: string;
    endTime: string;
    timezone?: string;
}
export interface DeviceBlockSchedule {
    id: string;
    deviceId: string;
    schedule: ScheduleConfig;
    enabled: boolean;
    description?: string;
    createdAt: Date;
    lastExecuted?: Date;
}
export interface EmergencyLockdown {
    id: string;
    enabled: boolean;
    activatedAt?: Date;
    activatedBy?: string;
    restrictions: {
        blockAllClients: boolean;
        blockInternetAccess: boolean;
        allowedDevices: string[];
        allowedNetworks: string[];
        customRules?: string[];
    };
    autoDisableAfter?: number;
}
export interface BulkOperation {
    id: string;
    operation: 'restart' | 'adopt' | 'upgrade' | 'block' | 'unblock';
    deviceIds: string[];
    status: 'pending' | 'in-progress' | 'completed' | 'failed';
    results: Array<{
        deviceId: string;
        success: boolean;
        error?: string;
    }>;
    startedAt: Date;
    completedAt?: Date;
}
export interface HealthCheck {
    timestamp: Date;
    overall: 'healthy' | 'warning' | 'critical';
    checks: Array<{
        name: string;
        status: 'pass' | 'warning' | 'fail';
        message: string;
        details?: Record<string, any>;
    }>;
}
export interface APIResponse<T = any> {
    meta: {
        msg: string;
        rc: 'ok' | 'error';
    };
    data: T[];
}
export interface APIError {
    meta: {
        msg: string;
        rc: 'error';
    };
    data: never[];
    error?: {
        code: string;
        message: string;
        details?: any;
    };
}
export declare const ConnectionParamsSchema: z.ZodObject<{
    gatewayIp: z.ZodString;
    apiKey: z.ZodString;
    siteId: z.ZodDefault<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    gatewayIp: string;
    apiKey: string;
    siteId: string;
}, {
    gatewayIp: string;
    apiKey: string;
    siteId?: string | undefined;
}>;
export declare const DeviceParamsSchema: z.ZodObject<{
    deviceId: z.ZodOptional<z.ZodString>;
    deviceType: z.ZodOptional<z.ZodNativeEnum<typeof DeviceType>>;
    status: z.ZodOptional<z.ZodNativeEnum<typeof DeviceStatus>>;
}, "strip", z.ZodTypeAny, {
    status?: DeviceStatus | undefined;
    deviceId?: string | undefined;
    deviceType?: DeviceType | undefined;
}, {
    status?: DeviceStatus | undefined;
    deviceId?: string | undefined;
    deviceType?: DeviceType | undefined;
}>;
export declare const ClientParamsSchema: z.ZodObject<{
    clientId: z.ZodOptional<z.ZodString>;
    activeOnly: z.ZodDefault<z.ZodBoolean>;
    networkId: z.ZodOptional<z.ZodString>;
    clientType: z.ZodOptional<z.ZodNativeEnum<typeof ClientType>>;
    blocked: z.ZodOptional<z.ZodBoolean>;
    includeTraffic: z.ZodDefault<z.ZodBoolean>;
    sortBy: z.ZodOptional<z.ZodEnum<["name", "ip", "mac", "lastSeen", "rxBytes", "txBytes"]>>;
    sortOrder: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
    limit: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    activeOnly: boolean;
    includeTraffic: boolean;
    sortOrder: "asc" | "desc";
    limit: number;
    networkId?: string | undefined;
    blocked?: boolean | undefined;
    clientId?: string | undefined;
    clientType?: ClientType | undefined;
    sortBy?: "name" | "lastSeen" | "txBytes" | "rxBytes" | "mac" | "ip" | undefined;
}, {
    networkId?: string | undefined;
    blocked?: boolean | undefined;
    clientId?: string | undefined;
    activeOnly?: boolean | undefined;
    clientType?: ClientType | undefined;
    includeTraffic?: boolean | undefined;
    sortBy?: "name" | "lastSeen" | "txBytes" | "rxBytes" | "mac" | "ip" | undefined;
    sortOrder?: "asc" | "desc" | undefined;
    limit?: number | undefined;
}>;
export declare const FirewallRuleParamsSchema: z.ZodObject<{
    ruleId: z.ZodOptional<z.ZodString>;
    enabledOnly: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    enabledOnly: boolean;
    ruleId?: string | undefined;
}, {
    ruleId?: string | undefined;
    enabledOnly?: boolean | undefined;
}>;
export declare const ZoneParamsSchema: z.ZodObject<{
    zoneId: z.ZodOptional<z.ZodString>;
    sourceZone: z.ZodOptional<z.ZodString>;
    targetZone: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    sourceZone?: string | undefined;
    targetZone?: string | undefined;
    zoneId?: string | undefined;
}, {
    sourceZone?: string | undefined;
    targetZone?: string | undefined;
    zoneId?: string | undefined;
}>;
export declare const NetworkParamsSchema: z.ZodObject<{
    networkId: z.ZodOptional<z.ZodString>;
    networkType: z.ZodOptional<z.ZodNativeEnum<typeof NetworkPurpose>>;
}, "strip", z.ZodTypeAny, {
    networkId?: string | undefined;
    networkType?: NetworkPurpose | undefined;
}, {
    networkId?: string | undefined;
    networkType?: NetworkPurpose | undefined;
}>;
export declare const MonitoringParamsSchema: z.ZodObject<{
    timeframe: z.ZodDefault<z.ZodEnum<["hour", "day", "week", "month"]>>;
    entityType: z.ZodOptional<z.ZodEnum<["client", "device", "network"]>>;
    entityId: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    timeframe: "hour" | "day" | "week" | "month";
    entityType?: "client" | "device" | "network" | undefined;
    entityId?: string | undefined;
}, {
    timeframe?: "hour" | "day" | "week" | "month" | undefined;
    entityType?: "client" | "device" | "network" | undefined;
    entityId?: string | undefined;
}>;
//# sourceMappingURL=types.d.ts.map