cloudflare-domain-manager/packages/shared/dist/index.d.ts

import { z } from 'zod';

declare const SYNC_SYNCED = "synced";
declare const SYNC_PENDING_PUSH = "pending_push";
declare const SYNC_PENDING_DELETE = "pending_delete";
declare const SYNC_CONFLICT = "conflict";
declare const SYNC_ERROR = "error";
declare const CERT_OK = "ok";
declare const CERT_WARNING = "warning";
declare const CERT_EXPIRED = "expired";
declare const CERT_ERROR = "error";
declare const CERT_UNKNOWN = "unknown";
declare const CERT_MONITOR_AUTO = "auto";
declare const CERT_MONITOR_REQUIRED = "required";
declare const CERT_MONITOR_SKIPPED = "skipped";
declare const CERT_MONITORING_VALUES: readonly ["auto", "required", "skipped"];

declare const HEALTH_CHECK_PROVIDERS: readonly ["local", "cloudflare", "globalping"];
type HealthCheckProvider = (typeof HEALTH_CHECK_PROVIDERS)[number];
declare const HEALTH_STATUS_PROVIDERS: readonly ["local", "cloudflare", "globalping", "aggregate"];
type HealthStatusProvider = (typeof HEALTH_STATUS_PROVIDERS)[number];
declare const HEALTH_CHECK_AGGREGATES: readonly ["any", "all", "majority"];
type HealthCheckAggregate = (typeof HEALTH_CHECK_AGGREGATES)[number];
declare function normalizeProbeProvider(value: unknown): HealthCheckProvider;
declare function normalizeStatusProvider(value: unknown): HealthStatusProvider;
declare function uniqueHealthProviders(values: readonly unknown[]): HealthCheckProvider[];
declare function parseHealthProviders(json: unknown, fallback?: unknown): HealthCheckProvider[];
declare function serializeHealthProviders(providers: readonly HealthCheckProvider[]): string;
declare function parseHealthAggregate(value: unknown): HealthCheckAggregate;
declare function derivePrimaryProvider(providers: readonly HealthCheckProvider[]): HealthCheckProvider;
declare function targetProviders(target: {
    providers?: readonly HealthCheckProvider[] | null;
    provider?: HealthCheckProvider | null;
}): HealthCheckProvider[];
declare function targetHasProvider(target: {
    providers?: readonly HealthCheckProvider[] | null;
    provider?: HealthCheckProvider | null;
}, provider: HealthCheckProvider): boolean;
/**
 * any — Down if at least one source is Down (ok only if all ok).
 * all — Down only if every source is Down (ok if any ok).
 * majority — Down if a strict majority of sources are Down (2 → both, 3 → ≥2).
 */
declare function aggregateHealthOk(oks: readonly boolean[], policy: HealthCheckAggregate): boolean;
declare function clampGlobalpingLimit(value: unknown, fallback?: number): number;
declare function parseGlobalpingLocations(value: unknown): string[];

interface ServiceGroup$1 {
    id: number;
    name: string;
    type: string;
    icon: string | null;
    domain: string | null;
    enabled: boolean;
    lb_mode: LbMode;
    health_check_enabled: boolean;
    health_check_type: HealthCheckType;
    health_check_port: number | null;
    health_check_path: string | null;
    health_check_expected_status: number | null;
    health_check_interval_sec: number;
    health_check_timeout_ms: number;
    health_check_verify_tls: boolean;
    health_check_provider: HealthCheckProvider;
    health_check_providers: HealthCheckProvider[];
    health_check_aggregate: HealthCheckAggregate;
    created_at: string;
    updated_at: string;
}
interface Subdomain {
    id: number;
    domain_id: number;
    name: string;
    fqdn: string;
    enabled: boolean;
    cert_monitoring: string;
    created_at: string;
    updated_at: string;
}
interface ServiceBinding {
    id: number;
    domain_id: number;
    service_id: number;
    hostname: string;
    cname_target: string | null;
    dns_record_id: number | null;
    lb_mode: LbMode;
    health_check_enabled: boolean;
    health_check_type: HealthCheckType;
    health_check_port: number | null;
    health_check_path: string | null;
    health_check_expected_status: number | null;
    health_check_interval_sec: number;
    health_check_timeout_ms: number;
    health_check_verify_tls: boolean;
    health_check_provider: HealthCheckProvider;
    health_check_providers: HealthCheckProvider[];
    health_check_aggregate: HealthCheckAggregate;
    cert_monitoring: string;
    routing_strategy: LbMode;
    operation_version: number;
    created_at: string;
    updated_at: string;
}
interface ServiceBindingView {
    id: number;
    domain_id: number;
    service_id: number;
    hostname: string;
    dns_record_id: number | null;
    zone_name: string;
    group_id: number | null;
    group_name: string | null;
    service_name: string;
    service_slug: string;
    target_ip: string | null;
    target_ips: string[];
    target_ip_weights: Record<string, number>;
    target_ip_priorities: Record<string, number>;
    cname_target: string | null;
    lb_mode: LbMode;
    health_check_enabled: boolean;
    health_check_type: HealthCheckType;
    health_check_port: number | null;
    health_check_path: string | null;
    health_check_expected_status: number | null;
    health_check_interval_sec: number;
    health_check_timeout_ms: number;
    health_check_verify_tls: boolean;
    health_check_provider: HealthCheckProvider;
    health_check_providers: HealthCheckProvider[];
    health_check_aggregate: HealthCheckAggregate;
    cert_monitoring: string;
    sync_status: string | null;
    created_at: string;
    updated_at: string;
}
interface ServiceDomainBindingView {
    binding_id: number;
    domain_id: number;
    zone_name: string;
    hostname: string;
    fqdn: string;
    record_type: "A" | "CNAME";
    target_ips: string[];
    active_ips: string[];
    target_ip_weights: Record<string, number>;
    target_ip_priorities: Record<string, number>;
    target_cname: string | null;
    lb_mode: LbMode;
    health_check_enabled: boolean;
    health_check_type: HealthCheckType;
    health_check_port: number | null;
    health_check_path: string | null;
    health_check_expected_status: number | null;
    health_check_interval_sec: number;
    health_check_timeout_ms: number;
    health_check_verify_tls: boolean;
    health_check_provider: HealthCheckProvider;
    health_check_providers: HealthCheckProvider[];
    health_check_aggregate: HealthCheckAggregate;
    cert_monitoring: string;
    sync_status: string | null;
}
interface ServiceView$1 {
    id: number;
    name: string;
    slug: string;
    service_group_id: number | null;
    subdomain: string;
    enabled: boolean;
    computed_fqdn: string | null;
    lb_weight: number;
    lb_priority: number;
    created_at: string;
    updated_at: string;
    ips: string[];
    domains: ServiceDomainBindingView[];
    health_status: IpHealthState;
    health_latency_ms: number | null;
    ip_health: ServiceIpHealth$1[];
    ip_enabled: Record<string, boolean>;
    lb_mode: LbMode;
    active_ips: string[];
}
interface SyncJob {
    id: string;
    status: string;
    domain_id: number | null;
    message: string | null;
    created_at: string;
    finished_at: string | null;
}
interface CfZone {
    id: string;
    name: string;
    status: string;
    account?: {
        id: string;
        name?: string;
    };
}
interface CfDnsRecord {
    id?: string;
    type: string;
    name: string;
    content: string;
    ttl: number;
    proxied?: boolean;
    priority?: number;
}
interface CreateDnsRecordPayload {
    type: string;
    name: string;
    content: string;
    ttl: number;
    proxied?: boolean;
    priority?: number;
}
interface LoginRequest {
    username: string;
    password: string;
}
interface LoginResponse {
    token: string;
    expires_at: string;
}
interface JwtClaims {
    sub: string;
    exp: number;
}
type LbMode = "round_robin" | "failover" | "weighted";
type HealthCheckType = "tcp" | "http" | "ping" | "dns";
type IpHealthState = "up" | "down" | "degraded" | "unknown";
type NodeHealthState = "unknown" | "checking" | "healthy" | "degraded" | "unhealthy" | "disabled";
type HealthCheckScope = "binding" | "group";
interface IpHealthStatus {
    scope: HealthCheckScope;
    ref_id: number;
    ip: string;
    status: IpHealthState;
    latency_ms: number | null;
    consecutive_failures: number;
    consecutive_successes?: number;
    last_checked_at: string | null;
    last_error: string | null;
    colo?: string | null;
    provider?: HealthStatusProvider;
}
interface ServiceIpHealth$1 {
    ip: string;
    status: IpHealthState;
    latency_ms: number | null;
    last_checked_at?: string | null;
    last_error?: string | null;
    provider?: HealthStatusProvider;
    colo?: string | null;
}
interface ServiceNode {
    id: number;
    service_id: number;
    address: string;
    protocol: string;
    port: number | null;
    enabled: boolean;
    priority: number;
    weight: number;
    health_status: NodeHealthState;
    health_check_id: number | null;
    consecutive_failures: number;
    consecutive_successes: number;
    last_check_at: string | null;
    last_failure_reason: string | null;
    created_at: string;
    updated_at: string;
}
interface OriginHealthCheck {
    id: number;
    provider: HealthCheckProvider;
    cf_healthcheck_id: string | null;
    cf_zone_id: string | null;
    name: string;
    protocol: string;
    path: string | null;
    method: string | null;
    timeout: number;
    interval_sec: number;
    retries: number;
    expected_status: number | null;
    consecutive_fails: number;
    consecutive_successes: number;
    suspended: boolean;
    created_at: string;
    updated_at: string;
}
interface ServiceOverview {
    service: ServiceView$1;
    nodes: ServiceNode[];
    health_check: OriginHealthCheck | null;
    routing_strategy: LbMode;
    active_addresses: string[];
}
interface PatchDnsRecordPayload {
    type?: string;
    name?: string;
    content?: string;
    ttl?: number;
    proxied?: boolean;
    priority?: number;
}
interface CfHealthCheck {
    id: string;
    address: string;
    name: string;
    status?: string;
    type?: string;
    interval?: number;
    timeout?: number;
    retries?: number;
    consecutive_fails?: number;
    consecutive_successes?: number;
    suspended?: boolean;
}
interface HealthCheckTarget {
    scope: HealthCheckScope;
    ref_id: number;
    ip: string;
    hostname: string;
    type: HealthCheckType;
    port: number | null;
    path: string | null;
    expected_status: number | null;
    timeout_ms: number;
    verify_tls: boolean;
    provider: HealthCheckProvider;
    providers?: HealthCheckProvider[];
    aggregate?: HealthCheckAggregate;
}

declare class ValidationError extends Error {
    constructor(message: string);
}
declare function validateDnsRecord(recordType: string, name: string, content: string, ttl: number, proxied: boolean): void;
declare function certStatusFromExpiry(daysLeft: number): string;
declare function shouldMonitorService(service: {
    enabled?: boolean;
    service_group_id?: number | null;
}, group?: Pick<ServiceGroup$1, "enabled"> | null): boolean;
declare function isValidIpv4(ip: string): boolean;
/** true для IPv4/IPv6; false для hostname (важно: CNAME content не должен считаться IP). */
declare function isIpLiteral(value: string): boolean;

declare function dnsNameToSubdomainLabel(recordName: string, zoneName: string): string | null;
declare function subdomainLabelToFqdn(label: string, zoneName: string): string;
/** Canonical DNS record name as returned by Cloudflare for a zone. */
declare function normalizeDnsRecordName(recordName: string, zoneName: string): string;
declare function dnsRecordNamesMatch(left: string, right: string, zoneName: string): boolean;

interface ParsedFqdn {
    zoneName: string;
    hostname: string;
    fqdn: string;
}
declare function fqdnToDisplay(hostname: string, zoneName: string): string;
declare function parseFqdn(fqdn: string, knownZones: string[]): ParsedFqdn | null;
declare function bindingToFqdn(binding: {
    hostname: string;
    zone_name: string;
    fqdn?: string;
}): string;

declare const certMonitoringSchema: z.ZodEnum<{
    auto: "auto";
    required: "required";
    skipped: "skipped";
}>;
type CertMonitoring = z.infer<typeof certMonitoringSchema>;
declare const lbModeSchema: z.ZodEnum<{
    round_robin: "round_robin";
    failover: "failover";
    weighted: "weighted";
}>;
declare const healthCheckTypeSchema: z.ZodEnum<{
    tcp: "tcp";
    http: "http";
    ping: "ping";
    dns: "dns";
}>;
declare const domainEnvironmentSchema: z.ZodEnum<{
    prod: "prod";
    staging: "staging";
    dev: "dev";
}>;
type DomainEnvironment = z.infer<typeof domainEnvironmentSchema>;
declare const domainMonitorTypeSchema: z.ZodEnum<{
    http: "http";
    ping: "ping";
    dns: "dns";
}>;
type DomainMonitorType = z.infer<typeof domainMonitorTypeSchema>;
declare const ipHealthStateSchema: z.ZodEnum<{
    unknown: "unknown";
    up: "up";
    down: "down";
    degraded: "degraded";
}>;
declare const nodeHealthStateSchema: z.ZodEnum<{
    unknown: "unknown";
    degraded: "degraded";
    checking: "checking";
    healthy: "healthy";
    unhealthy: "unhealthy";
    disabled: "disabled";
}>;
declare const healthCheckProviderSchema: z.ZodEnum<{
    local: "local";
    cloudflare: "cloudflare";
    globalping: "globalping";
}>;
declare const healthStatusProviderSchema: z.ZodEnum<{
    local: "local";
    cloudflare: "cloudflare";
    globalping: "globalping";
    aggregate: "aggregate";
}>;
declare const healthCheckAggregateSchema: z.ZodEnum<{
    any: "any";
    all: "all";
    majority: "majority";
}>;
declare const healthCheckProvidersSchema: z.ZodPreprocess<z.ZodPipe<z.ZodArray<z.ZodEnum<{
    local: "local";
    cloudflare: "cloudflare";
    globalping: "globalping";
}>>, z.ZodTransform<("local" | "cloudflare" | "globalping")[] | readonly ["local"], ("local" | "cloudflare" | "globalping")[]>>>;
declare const healthCheckScopeSchema: z.ZodEnum<{
    binding: "binding";
    group: "group";
}>;
declare const ipHealthStatusSchema: z.ZodObject<{
    scope: z.ZodEnum<{
        binding: "binding";
        group: "group";
    }>;
    ref_id: z.ZodNumber;
    ip: z.ZodString;
    status: z.ZodEnum<{
        unknown: "unknown";
        up: "up";
        down: "down";
        degraded: "degraded";
    }>;
    latency_ms: z.ZodNullable<z.ZodNumber>;
    consecutive_failures: z.ZodNumber;
    consecutive_successes: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    last_checked_at: z.ZodNullable<z.ZodString>;
    last_error: z.ZodNullable<z.ZodString>;
    colo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    provider: z.ZodOptional<z.ZodEnum<{
        local: "local";
        cloudflare: "cloudflare";
        globalping: "globalping";
        aggregate: "aggregate";
    }>>;
}, z.core.$strip>;
declare const serviceIpHealthSchema: z.ZodObject<{
    ip: z.ZodString;
    status: z.ZodEnum<{
        unknown: "unknown";
        up: "up";
        down: "down";
        degraded: "degraded";
    }>;
    latency_ms: z.ZodNullable<z.ZodNumber>;
    last_checked_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    last_error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    provider: z.ZodOptional<z.ZodEnum<{
        local: "local";
        cloudflare: "cloudflare";
        globalping: "globalping";
        aggregate: "aggregate";
    }>>;
    colo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
}, z.core.$strip>;
type ServiceIpHealth = z.infer<typeof serviceIpHealthSchema>;
declare const healthProbeLogSchema: z.ZodObject<{
    id: z.ZodNumber;
    scope: z.ZodString;
    ref_id: z.ZodNumber;
    ip: z.ZodString;
    provider: z.ZodEnum<{
        local: "local";
        cloudflare: "cloudflare";
        globalping: "globalping";
    }>;
    status: z.ZodEnum<{
        unknown: "unknown";
        up: "up";
        down: "down";
        degraded: "degraded";
    }>;
    ok: z.ZodCoercedBoolean<unknown>;
    latency_ms: z.ZodNullable<z.ZodNumber>;
    colo: z.ZodNullable<z.ZodString>;
    error: z.ZodNullable<z.ZodString>;
    checked_at: z.ZodString;
}, z.core.$strip>;
type HealthProbeLog = z.infer<typeof healthProbeLogSchema>;
declare const failoverLogSchema: z.ZodObject<{
    id: z.ZodNumber;
    service_id: z.ZodNumber;
    binding_id: z.ZodNumber;
    fqdn: z.ZodString;
    ip: z.ZodString;
    action: z.ZodEnum<{
        added: "added";
        removed: "removed";
    }>;
    created_at: z.ZodString;
}, z.core.$strip>;
type FailoverLogEntry = z.infer<typeof failoverLogSchema>;
declare const groupSchema: z.ZodObject<{
    id: z.ZodNumber;
    name: z.ZodString;
    slug: z.ZodString;
    created_at: z.ZodString;
    updated_at: z.ZodString;
}, z.core.$strip>;
declare const groupWithStatsSchema: z.ZodObject<{
    id: z.ZodNumber;
    name: z.ZodString;
    slug: z.ZodString;
    created_at: z.ZodString;
    updated_at: z.ZodString;
    domain_count: z.ZodNumber;
}, z.core.$strip>;
declare const serviceGroupTypeSchema: z.ZodEnum<{
    custom: "custom";
    vpn: "vpn";
    network: "network";
    internet: "internet";
    bgp: "bgp";
}>;
declare const serviceGroupSchema: z.ZodObject<{
    id: z.ZodNumber;
    name: z.ZodString;
    type: z.ZodCatch<z.ZodEnum<{
        custom: "custom";
        vpn: "vpn";
        network: "network";
        internet: "internet";
        bgp: "bgp";
    }>>;
    icon: z.ZodDefault<z.ZodNullable<z.ZodString>>;
    domain: z.ZodDefault<z.ZodNullable<z.ZodString>>;
    enabled: z.ZodCoercedBoolean<unknown>;
    lb_mode: z.ZodCatch<z.ZodEnum<{
        round_robin: "round_robin";
        failover: "failover";
        weighted: "weighted";
    }>>;
    health_check_enabled: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
    health_check_type: z.ZodCatch<z.ZodEnum<{
        tcp: "tcp";
        http: "http";
        ping: "ping";
        dns: "dns";
    }>>;
    health_check_port: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
    health_check_path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
    health_check_expected_status: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
    health_check_interval_sec: z.ZodDefault<z.ZodNumber>;
    health_check_timeout_ms: z.ZodDefault<z.ZodNumber>;
    health_check_verify_tls: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
    health_check_provider: z.ZodCatch<z.ZodEnum<{
        local: "local";
        cloudflare: "cloudflare";
        globalping: "globalping";
    }>>;
    health_check_providers: z.ZodCatch<z.ZodPreprocess<z.ZodPipe<z.ZodArray<z.ZodEnum<{
        local: "local";
        cloudflare: "cloudflare";
        globalping: "globalping";
    }>>, z.ZodTransform<("local" | "cloudflare" | "globalping")[] | readonly ["local"], ("local" | "cloudflare" | "globalping")[]>>>>;
    health_check_aggregate: z.ZodCatch<z.ZodEnum<{
        any: "any";
        all: "all";
        majority: "majority";
    }>>;
    created_at: z.ZodString;
    updated_at: z.ZodString;
}, z.core.$strip>;
declare const serviceSchema: z.ZodObject<{
    id: z.ZodNumber;
    name: z.ZodString;
    slug: z.ZodString;
    service_group_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    subdomain: z.ZodOptional<z.ZodString>;
    enabled: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
    computed_fqdn: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    lb_weight: z.ZodDefault<z.ZodNumber>;
    lb_priority: z.ZodDefault<z.ZodNumber>;
    created_at: z.ZodString;
    updated_at: z.ZodString;
}, z.core.$strip>;
declare const serviceDomainBindingSchema: z.ZodPipe<z.ZodObject<{
    binding_id: z.ZodNumber;
    domain_id: z.ZodNumber;
    zone_name: z.ZodString;
    hostname: z.ZodString;
    fqdn: z.ZodString;
    record_type: z.ZodDefault<z.ZodEnum<{
        A: "A";
        CNAME: "CNAME";
    }>>;
    target_ips: z.ZodOptional<z.ZodArray<z.ZodString>>;
    target_ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    target_ip_weights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodCoercedNumber<unknown>>>;
    target_ip_priorities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodCoercedNumber<unknown>>>;
    target_cname: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    lb_mode: z.ZodCatch<z.ZodEnum<{
        round_robin: "round_robin";
        failover: "failover";
        weighted: "weighted";
    }>>;
    health_check_enabled: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
    health_check_type: z.ZodCatch<z.ZodEnum<{
        tcp: "tcp";
        http: "http";
        ping: "ping";
        dns: "dns";
    }>>;
    health_check_port: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
    health_check_path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
    health_check_expected_status: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
    health_check_interval_sec: z.ZodDefault<z.ZodNumber>;
    health_check_timeout_ms: z.ZodDefault<z.ZodNumber>;
    health_check_verify_tls: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
    health_check_provider: z.ZodCatch<z.ZodEnum<{
        local: "local";
        cloudflare: "cloudflare";
        globalping: "globalping";
    }>>;
    health_check_providers: z.ZodCatch<z.ZodPreprocess<z.ZodPipe<z.ZodArray<z.ZodEnum<{
        local: "local";
        cloudflare: "cloudflare";
        globalping: "globalping";
    }>>, z.ZodTransform<("local" | "cloudflare" | "globalping")[] | readonly ["local"], ("local" | "cloudflare" | "globalping")[]>>>>;
    health_check_aggregate: z.ZodCatch<z.ZodEnum<{
        any: "any";
        all: "all";
        majority: "majority";
    }>>;
    cert_monitoring: z.ZodDefault<z.ZodEnum<{
        auto: "auto";
        required: "required";
        skipped: "skipped";
    }>>;
    sync_status: z.ZodDefault<z.ZodNullable<z.ZodString>>;
    active_ips: z.ZodDefault<z.ZodArray<z.ZodString>>;
}, z.core.$strip>, z.ZodTransform<{
    target_ips: string[];
    target_ip_weights: Record<string, number>;
    target_ip_priorities: Record<string, number>;
    target_cname: string | null;
    record_type: "A" | "CNAME";
    binding_id: number;
    domain_id: number;
    zone_name: string;
    hostname: string;
    fqdn: string;
    lb_mode: "round_robin" | "failover" | "weighted";
    health_check_enabled: boolean;
    health_check_type: "tcp" | "http" | "ping" | "dns";
    health_check_port: number | null;
    health_check_path: string | null;
    health_check_expected_status: number | null;
    health_check_interval_sec: number;
    health_check_timeout_ms: number;
    health_check_verify_tls: boolean;
    health_check_provider: "local" | "cloudflare" | "globalping";
    health_check_providers: ("local" | "cloudflare" | "globalping")[] | readonly ["local"];
    health_check_aggregate: "any" | "all" | "majority";
    cert_monitoring: "auto" | "required" | "skipped";
    sync_status: string | null;
    active_ips: string[];
    target_ip?: string | null | undefined;
}, {
    binding_id: number;
    domain_id: number;
    zone_name: string;
    hostname: string;
    fqdn: string;
    record_type: "A" | "CNAME";
    lb_mode: "round_robin" | "failover" | "weighted";
    health_check_enabled: boolean;
    health_check_type: "tcp" | "http" | "ping" | "dns";
    health_check_port: number | null;
    health_check_path: string | null;
    health_check_expected_status: number | null;
    health_check_interval_sec: number;
    health_check_timeout_ms: number;
    health_check_verify_tls: boolean;
    health_check_provider: "local" | "cloudflare" | "globalping";
    health_check_providers: ("local" | "cloudflare" | "globalping")[] | readonly ["local"];
    health_check_aggregate: "any" | "all" | "majority";
    cert_monitoring: "auto" | "required" | "skipped";
    sync_status: string | null;
    active_ips: string[];
    target_ips?: string[] | undefined;
    target_ip?: string | null | undefined;
    target_ip_weights?: Record<string, number> | undefined;
    target_ip_priorities?: Record<string, number> | undefined;
    target_cname?: string | null | undefined;
}>>;
declare const serviceViewSchema: z.ZodObject<{
    id: z.ZodNumber;
    name: z.ZodString;
    slug: z.ZodString;
    service_group_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    computed_fqdn: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    lb_weight: z.ZodDefault<z.ZodNumber>;
    lb_priority: z.ZodDefault<z.ZodNumber>;
    created_at: z.ZodString;
    updated_at: z.ZodString;
    subdomain: z.ZodDefault<z.ZodString>;
    enabled: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
    ips: z.ZodDefault<z.ZodArray<z.ZodString>>;
    domains: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodObject<{
        binding_id: z.ZodNumber;
        domain_id: z.ZodNumber;
        zone_name: z.ZodString;
        hostname: z.ZodString;
        fqdn: z.ZodString;
        record_type: z.ZodDefault<z.ZodEnum<{
            A: "A";
            CNAME: "CNAME";
        }>>;
        target_ips: z.ZodOptional<z.ZodArray<z.ZodString>>;
        target_ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        target_ip_weights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodCoercedNumber<unknown>>>;
        target_ip_priorities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodCoercedNumber<unknown>>>;
        target_cname: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        lb_mode: z.ZodCatch<z.ZodEnum<{
            round_robin: "round_robin";
            failover: "failover";
            weighted: "weighted";
        }>>;
        health_check_enabled: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
        health_check_type: z.ZodCatch<z.ZodEnum<{
            tcp: "tcp";
            http: "http";
            ping: "ping";
            dns: "dns";
        }>>;
        health_check_port: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
        health_check_path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        health_check_expected_status: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
        health_check_interval_sec: z.ZodDefault<z.ZodNumber>;
        health_check_timeout_ms: z.ZodDefault<z.ZodNumber>;
        health_check_verify_tls: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
        health_check_provider: z.ZodCatch<z.ZodEnum<{
            local: "local";
            cloudflare: "cloudflare";
            globalping: "globalping";
        }>>;
        health_check_providers: z.ZodCatch<z.ZodPreprocess<z.ZodPipe<z.ZodArray<z.ZodEnum<{
            local: "local";
            cloudflare: "cloudflare";
            globalping: "globalping";
        }>>, z.ZodTransform<("local" | "cloudflare" | "globalping")[] | readonly ["local"], ("local" | "cloudflare" | "globalping")[]>>>>;
        health_check_aggregate: z.ZodCatch<z.ZodEnum<{
            any: "any";
            all: "all";
            majority: "majority";
        }>>;
        cert_monitoring: z.ZodDefault<z.ZodEnum<{
            auto: "auto";
            required: "required";
            skipped: "skipped";
        }>>;
        sync_status: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        active_ips: z.ZodDefault<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>, z.ZodTransform<{
        target_ips: string[];
        target_ip_weights: Record<string, number>;
        target_ip_priorities: Record<string, number>;
        target_cname: string | null;
        record_type: "A" | "CNAME";
        binding_id: number;
        domain_id: number;
        zone_name: string;
        hostname: string;
        fqdn: string;
        lb_mode: "round_robin" | "failover" | "weighted";
        health_check_enabled: boolean;
        health_check_type: "tcp" | "http" | "ping" | "dns";
        health_check_port: number | null;
        health_check_path: string | null;
        health_check_expected_status: number | null;
        health_check_interval_sec: number;
        health_check_timeout_ms: number;
        health_check_verify_tls: boolean;
        health_check_provider: "local" | "cloudflare" | "globalping";
        health_check_providers: ("local" | "cloudflare" | "globalping")[] | readonly ["local"];
        health_check_aggregate: "any" | "all" | "majority";
        cert_monitoring: "auto" | "required" | "skipped";
        sync_status: string | null;
        active_ips: string[];
        target_ip?: string | null | undefined;
    }, {
        binding_id: number;
        domain_id: number;
        zone_name: string;
        hostname: string;
        fqdn: string;
        record_type: "A" | "CNAME";
        lb_mode: "round_robin" | "failover" | "weighted";
        health_check_enabled: boolean;
        health_check_type: "tcp" | "http" | "ping" | "dns";
        health_check_port: number | null;
        health_check_path: string | null;
        health_check_expected_status: number | null;
        health_check_interval_sec: number;
        health_check_timeout_ms: number;
        health_check_verify_tls: boolean;
        health_check_provider: "local" | "cloudflare" | "globalping";
        health_check_providers: ("local" | "cloudflare" | "globalping")[] | readonly ["local"];
        health_check_aggregate: "any" | "all" | "majority";
        cert_monitoring: "auto" | "required" | "skipped";
        sync_status: string | null;
        active_ips: string[];
        target_ips?: string[] | undefined;
        target_ip?: string | null | undefined;
        target_ip_weights?: Record<string, number> | undefined;
        target_ip_priorities?: Record<string, number> | undefined;
        target_cname?: string | null | undefined;
    }>>>>;
    health_status: z.ZodDefault<z.ZodEnum<{
        unknown: "unknown";
        up: "up";
        down: "down";
        degraded: "degraded";
    }>>;
    health_latency_ms: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
    ip_health: z.ZodDefault<z.ZodArray<z.ZodObject<{
        ip: z.ZodString;
        status: z.ZodEnum<{
            unknown: "unknown";
            up: "up";
            down: "down";
            degraded: "degraded";
        }>;
        latency_ms: z.ZodNullable<z.ZodNumber>;
        last_checked_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        last_error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        provider: z.ZodOptional<z.ZodEnum<{
            local: "local";
            cloudflare: "cloudflare";
            globalping: "globalping";
            aggregate: "aggregate";
        }>>;
        colo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.core.$strip>>>;
    ip_enabled: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
    lb_mode: z.ZodCatch<z.ZodEnum<{
        round_robin: "round_robin";
        failover: "failover";
        weighted: "weighted";
    }>>;
    active_ips: z.ZodDefault<z.ZodArray<z.ZodString>>;
}, z.core.$strip>;
declare const serviceGroupViewSchema: z.ZodObject<{
    id: z.ZodNumber;
    name: z.ZodString;
    type: z.ZodCatch<z.ZodEnum<{
        custom: "custom";
        vpn: "vpn";
        network: "network";
        internet: "internet";
        bgp: "bgp";
    }>>;
    icon: z.ZodDefault<z.ZodNullable<z.ZodString>>;
    domain: z.ZodDefault<z.ZodNullable<z.ZodString>>;
    enabled: z.ZodCoercedBoolean<unknown>;
    lb_mode: z.ZodCatch<z.ZodEnum<{
        round_robin: "round_robin";
        failover: "failover";
        weighted: "weighted";
    }>>;
    health_check_enabled: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
    health_check_type: z.ZodCatch<z.ZodEnum<{
        tcp: "tcp";
        http: "http";
        ping: "ping";
        dns: "dns";
    }>>;
    health_check_port: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
    health_check_path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
    health_check_expected_status: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
    health_check_interval_sec: z.ZodDefault<z.ZodNumber>;
    health_check_timeout_ms: z.ZodDefault<z.ZodNumber>;
    health_check_verify_tls: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
    health_check_provider: z.ZodCatch<z.ZodEnum<{
        local: "local";
        cloudflare: "cloudflare";
        globalping: "globalping";
    }>>;
    health_check_providers: z.ZodCatch<z.ZodPreprocess<z.ZodPipe<z.ZodArray<z.ZodEnum<{
        local: "local";
        cloudflare: "cloudflare";
        globalping: "globalping";
    }>>, z.ZodTransform<("local" | "cloudflare" | "globalping")[] | readonly ["local"], ("local" | "cloudflare" | "globalping")[]>>>>;
    health_check_aggregate: z.ZodCatch<z.ZodEnum<{
        any: "any";
        all: "all";
        majority: "majority";
    }>>;
    created_at: z.ZodString;
    updated_at: z.ZodString;
    services: z.ZodDefault<z.ZodArray<z.ZodObject<{
        id: z.ZodNumber;
        name: z.ZodString;
        slug: z.ZodString;
        service_group_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        computed_fqdn: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        lb_weight: z.ZodDefault<z.ZodNumber>;
        lb_priority: z.ZodDefault<z.ZodNumber>;
        created_at: z.ZodString;
        updated_at: z.ZodString;
        subdomain: z.ZodDefault<z.ZodString>;
        enabled: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
        ips: z.ZodDefault<z.ZodArray<z.ZodString>>;
        domains: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodObject<{
            binding_id: z.ZodNumber;
            domain_id: z.ZodNumber;
            zone_name: z.ZodString;
            hostname: z.ZodString;
            fqdn: z.ZodString;
            record_type: z.ZodDefault<z.ZodEnum<{
                A: "A";
                CNAME: "CNAME";
            }>>;
            target_ips: z.ZodOptional<z.ZodArray<z.ZodString>>;
            target_ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            target_ip_weights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodCoercedNumber<unknown>>>;
            target_ip_priorities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodCoercedNumber<unknown>>>;
            target_cname: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            lb_mode: z.ZodCatch<z.ZodEnum<{
                round_robin: "round_robin";
                failover: "failover";
                weighted: "weighted";
            }>>;
            health_check_enabled: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
            health_check_type: z.ZodCatch<z.ZodEnum<{
                tcp: "tcp";
                http: "http";
                ping: "ping";
                dns: "dns";
            }>>;
            health_check_port: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
            health_check_path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            health_check_expected_status: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
            health_check_interval_sec: z.ZodDefault<z.ZodNumber>;
            health_check_timeout_ms: z.ZodDefault<z.ZodNumber>;
            health_check_verify_tls: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
            health_check_provider: z.ZodCatch<z.ZodEnum<{
                local: "local";
                cloudflare: "cloudflare";
                globalping: "globalping";
            }>>;
            health_check_providers: z.ZodCatch<z.ZodPreprocess<z.ZodPipe<z.ZodArray<z.ZodEnum<{
                local: "local";
                cloudflare: "cloudflare";
                globalping: "globalping";
            }>>, z.ZodTransform<("local" | "cloudflare" | "globalping")[] | readonly ["local"], ("local" | "cloudflare" | "globalping")[]>>>>;
            health_check_aggregate: z.ZodCatch<z.ZodEnum<{
                any: "any";
                all: "all";
                majority: "majority";
            }>>;
            cert_monitoring: z.ZodDefault<z.ZodEnum<{
                auto: "auto";
                required: "required";
                skipped: "skipped";
            }>>;
            sync_status: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            active_ips: z.ZodDefault<z.ZodArray<z.ZodString>>;
        }, z.core.$strip>, z.ZodTransform<{
            target_ips: string[];
            target_ip_weights: Record<string, number>;
            target_ip_priorities: Record<string, number>;
            target_cname: string | null;
            record_type: "A" | "CNAME";
            binding_id: number;
            domain_id: number;
            zone_name: string;
            hostname: string;
            fqdn: string;
            lb_mode: "round_robin" | "failover" | "weighted";
            health_check_enabled: boolean;
            health_check_type: "tcp" | "http" | "ping" | "dns";
            health_check_port: number | null;
            health_check_path: string | null;
            health_check_expected_status: number | null;
            health_check_interval_sec: number;
            health_check_timeout_ms: number;
            health_check_verify_tls: boolean;
            health_check_provider: "local" | "cloudflare" | "globalping";
            health_check_providers: ("local" | "cloudflare" | "globalping")[] | readonly ["local"];
            health_check_aggregate: "any" | "all" | "majority";
            cert_monitoring: "auto" | "required" | "skipped";
            sync_status: string | null;
            active_ips: string[];
            target_ip?: string | null | undefined;
        }, {
            binding_id: number;
            domain_id: number;
            zone_name: string;
            hostname: string;
            fqdn: string;
            record_type: "A" | "CNAME";
            lb_mode: "round_robin" | "failover" | "weighted";
            health_check_enabled: boolean;
            health_check_type: "tcp" | "http" | "ping" | "dns";
            health_check_port: number | null;
            health_check_path: string | null;
            health_check_expected_status: number | null;
            health_check_interval_sec: number;
            health_check_timeout_ms: number;
            health_check_verify_tls: boolean;
            health_check_provider: "local" | "cloudflare" | "globalping";
            health_check_providers: ("local" | "cloudflare" | "globalping")[] | readonly ["local"];
            health_check_aggregate: "any" | "all" | "majority";
            cert_monitoring: "auto" | "required" | "skipped";
            sync_status: string | null;
            active_ips: string[];
            target_ips?: string[] | undefined;
            target_ip?: string | null | undefined;
            target_ip_weights?: Record<string, number> | undefined;
            target_ip_priorities?: Record<string, number> | undefined;
            target_cname?: string | null | undefined;
        }>>>>;
        health_status: z.ZodDefault<z.ZodEnum<{
            unknown: "unknown";
            up: "up";
            down: "down";
            degraded: "degraded";
        }>>;
        health_latency_ms: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
        ip_health: z.ZodDefault<z.ZodArray<z.ZodObject<{
            ip: z.ZodString;
            status: z.ZodEnum<{
                unknown: "unknown";
                up: "up";
                down: "down";
                degraded: "degraded";
            }>;
            latency_ms: z.ZodNullable<z.ZodNumber>;
            last_checked_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            last_error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            provider: z.ZodOptional<z.ZodEnum<{
                local: "local";
                cloudflare: "cloudflare";
                globalping: "globalping";
                aggregate: "aggregate";
            }>>;
            colo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        }, z.core.$strip>>>;
        ip_enabled: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
        lb_mode: z.ZodCatch<z.ZodEnum<{
            round_robin: "round_robin";
            failover: "failover";
            weighted: "weighted";
        }>>;
        active_ips: z.ZodDefault<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>>>;
    health_status: z.ZodDefault<z.ZodEnum<{
        unknown: "unknown";
        up: "up";
        down: "down";
        degraded: "degraded";
    }>>;
    health_latency_ms: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
}, z.core.$strip>;
declare const serviceGroupsResponseSchema: z.ZodObject<{
    groups: z.ZodDefault<z.ZodArray<z.ZodObject<{
        id: z.ZodNumber;
        name: z.ZodString;
        type: z.ZodCatch<z.ZodEnum<{
            custom: "custom";
            vpn: "vpn";
            network: "network";
            internet: "internet";
            bgp: "bgp";
        }>>;
        icon: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        domain: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        enabled: z.ZodCoercedBoolean<unknown>;
        lb_mode: z.ZodCatch<z.ZodEnum<{
            round_robin: "round_robin";
            failover: "failover";
            weighted: "weighted";
        }>>;
        health_check_enabled: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
        health_check_type: z.ZodCatch<z.ZodEnum<{
            tcp: "tcp";
            http: "http";
            ping: "ping";
            dns: "dns";
        }>>;
        health_check_port: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
        health_check_path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        health_check_expected_status: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
        health_check_interval_sec: z.ZodDefault<z.ZodNumber>;
        health_check_timeout_ms: z.ZodDefault<z.ZodNumber>;
        health_check_verify_tls: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
        health_check_provider: z.ZodCatch<z.ZodEnum<{
            local: "local";
            cloudflare: "cloudflare";
            globalping: "globalping";
        }>>;
        health_check_providers: z.ZodCatch<z.ZodPreprocess<z.ZodPipe<z.ZodArray<z.ZodEnum<{
            local: "local";
            cloudflare: "cloudflare";
            globalping: "globalping";
        }>>, z.ZodTransform<("local" | "cloudflare" | "globalping")[] | readonly ["local"], ("local" | "cloudflare" | "globalping")[]>>>>;
        health_check_aggregate: z.ZodCatch<z.ZodEnum<{
            any: "any";
            all: "all";
            majority: "majority";
        }>>;
        created_at: z.ZodString;
        updated_at: z.ZodString;
        services: z.ZodDefault<z.ZodArray<z.ZodObject<{
            id: z.ZodNumber;
            name: z.ZodString;
            slug: z.ZodString;
            service_group_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
            computed_fqdn: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            lb_weight: z.ZodDefault<z.ZodNumber>;
            lb_priority: z.ZodDefault<z.ZodNumber>;
            created_at: z.ZodString;
            updated_at: z.ZodString;
            subdomain: z.ZodDefault<z.ZodString>;
            enabled: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
            ips: z.ZodDefault<z.ZodArray<z.ZodString>>;
            domains: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodObject<{
                binding_id: z.ZodNumber;
                domain_id: z.ZodNumber;
                zone_name: z.ZodString;
                hostname: z.ZodString;
                fqdn: z.ZodString;
                record_type: z.ZodDefault<z.ZodEnum<{
                    A: "A";
                    CNAME: "CNAME";
                }>>;
                target_ips: z.ZodOptional<z.ZodArray<z.ZodString>>;
                target_ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                target_ip_weights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodCoercedNumber<unknown>>>;
                target_ip_priorities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodCoercedNumber<unknown>>>;
                target_cname: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                lb_mode: z.ZodCatch<z.ZodEnum<{
                    round_robin: "round_robin";
                    failover: "failover";
                    weighted: "weighted";
                }>>;
                health_check_enabled: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
                health_check_type: z.ZodCatch<z.ZodEnum<{
                    tcp: "tcp";
                    http: "http";
                    ping: "ping";
                    dns: "dns";
                }>>;
                health_check_port: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
                health_check_path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                health_check_expected_status: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
                health_check_interval_sec: z.ZodDefault<z.ZodNumber>;
                health_check_timeout_ms: z.ZodDefault<z.ZodNumber>;
                health_check_verify_tls: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
                health_check_provider: z.ZodCatch<z.ZodEnum<{
                    local: "local";
                    cloudflare: "cloudflare";
                    globalping: "globalping";
                }>>;
                health_check_providers: z.ZodCatch<z.ZodPreprocess<z.ZodPipe<z.ZodArray<z.ZodEnum<{
                    local: "local";
                    cloudflare: "cloudflare";
                    globalping: "globalping";
                }>>, z.ZodTransform<("local" | "cloudflare" | "globalping")[] | readonly ["local"], ("local" | "cloudflare" | "globalping")[]>>>>;
                health_check_aggregate: z.ZodCatch<z.ZodEnum<{
                    any: "any";
                    all: "all";
                    majority: "majority";
                }>>;
                cert_monitoring: z.ZodDefault<z.ZodEnum<{
                    auto: "auto";
                    required: "required";
                    skipped: "skipped";
                }>>;
                sync_status: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                active_ips: z.ZodDefault<z.ZodArray<z.ZodString>>;
            }, z.core.$strip>, z.ZodTransform<{
                target_ips: string[];
                target_ip_weights: Record<string, number>;
                target_ip_priorities: Record<string, number>;
                target_cname: string | null;
                record_type: "A" | "CNAME";
                binding_id: number;
                domain_id: number;
                zone_name: string;
                hostname: string;
                fqdn: string;
                lb_mode: "round_robin" | "failover" | "weighted";
                health_check_enabled: boolean;
                health_check_type: "tcp" | "http" | "ping" | "dns";
                health_check_port: number | null;
                health_check_path: string | null;
                health_check_expected_status: number | null;
                health_check_interval_sec: number;
                health_check_timeout_ms: number;
                health_check_verify_tls: boolean;
                health_check_provider: "local" | "cloudflare" | "globalping";
                health_check_providers: ("local" | "cloudflare" | "globalping")[] | readonly ["local"];
                health_check_aggregate: "any" | "all" | "majority";
                cert_monitoring: "auto" | "required" | "skipped";
                sync_status: string | null;
                active_ips: string[];
                target_ip?: string | null | undefined;
            }, {
                binding_id: number;
                domain_id: number;
                zone_name: string;
                hostname: string;
                fqdn: string;
                record_type: "A" | "CNAME";
                lb_mode: "round_robin" | "failover" | "weighted";
                health_check_enabled: boolean;
                health_check_type: "tcp" | "http" | "ping" | "dns";
                health_check_port: number | null;
                health_check_path: string | null;
                health_check_expected_status: number | null;
                health_check_interval_sec: number;
                health_check_timeout_ms: number;
                health_check_verify_tls: boolean;
                health_check_provider: "local" | "cloudflare" | "globalping";
                health_check_providers: ("local" | "cloudflare" | "globalping")[] | readonly ["local"];
                health_check_aggregate: "any" | "all" | "majority";
                cert_monitoring: "auto" | "required" | "skipped";
                sync_status: string | null;
                active_ips: string[];
                target_ips?: string[] | undefined;
                target_ip?: string | null | undefined;
                target_ip_weights?: Record<string, number> | undefined;
                target_ip_priorities?: Record<string, number> | undefined;
                target_cname?: string | null | undefined;
            }>>>>;
            health_status: z.ZodDefault<z.ZodEnum<{
                unknown: "unknown";
                up: "up";
                down: "down";
                degraded: "degraded";
            }>>;
            health_latency_ms: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
            ip_health: z.ZodDefault<z.ZodArray<z.ZodObject<{
                ip: z.ZodString;
                status: z.ZodEnum<{
                    unknown: "unknown";
                    up: "up";
                    down: "down";
                    degraded: "degraded";
                }>;
                latency_ms: z.ZodNullable<z.ZodNumber>;
                last_checked_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                last_error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                provider: z.ZodOptional<z.ZodEnum<{
                    local: "local";
                    cloudflare: "cloudflare";
                    globalping: "globalping";
                    aggregate: "aggregate";
                }>>;
                colo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            }, z.core.$strip>>>;
            ip_enabled: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
            lb_mode: z.ZodCatch<z.ZodEnum<{
                round_robin: "round_robin";
                failover: "failover";
                weighted: "weighted";
            }>>;
            active_ips: z.ZodDefault<z.ZodArray<z.ZodString>>;
        }, z.core.$strip>>>;
        health_status: z.ZodDefault<z.ZodEnum<{
            unknown: "unknown";
            up: "up";
            down: "down";
            degraded: "degraded";
        }>>;
        health_latency_ms: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
    }, z.core.$strip>>>;
    ungrouped: z.ZodDefault<z.ZodArray<z.ZodObject<{
        id: z.ZodNumber;
        name: z.ZodString;
        slug: z.ZodString;
        service_group_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        computed_fqdn: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        lb_weight: z.ZodDefault<z.ZodNumber>;
        lb_priority: z.ZodDefault<z.ZodNumber>;
        created_at: z.ZodString;
        updated_at: z.ZodString;
        subdomain: z.ZodDefault<z.ZodString>;
        enabled: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
        ips: z.ZodDefault<z.ZodArray<z.ZodString>>;
        domains: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodObject<{
            binding_id: z.ZodNumber;
            domain_id: z.ZodNumber;
            zone_name: z.ZodString;
            hostname: z.ZodString;
            fqdn: z.ZodString;
            record_type: z.ZodDefault<z.ZodEnum<{
                A: "A";
                CNAME: "CNAME";
            }>>;
            target_ips: z.ZodOptional<z.ZodArray<z.ZodString>>;
            target_ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            target_ip_weights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodCoercedNumber<unknown>>>;
            target_ip_priorities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodCoercedNumber<unknown>>>;
            target_cname: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            lb_mode: z.ZodCatch<z.ZodEnum<{
                round_robin: "round_robin";
                failover: "failover";
                weighted: "weighted";
            }>>;
            health_check_enabled: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
            health_check_type: z.ZodCatch<z.ZodEnum<{
                tcp: "tcp";
                http: "http";
                ping: "ping";
                dns: "dns";
            }>>;
            health_check_port: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
            health_check_path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            health_check_expected_status: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
            health_check_interval_sec: z.ZodDefault<z.ZodNumber>;
            health_check_timeout_ms: z.ZodDefault<z.ZodNumber>;
            health_check_verify_tls: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
            health_check_provider: z.ZodCatch<z.ZodEnum<{
                local: "local";
                cloudflare: "cloudflare";
                globalping: "globalping";
            }>>;
            health_check_providers: z.ZodCatch<z.ZodPreprocess<z.ZodPipe<z.ZodArray<z.ZodEnum<{
                local: "local";
                cloudflare: "cloudflare";
                globalping: "globalping";
            }>>, z.ZodTransform<("local" | "cloudflare" | "globalping")[] | readonly ["local"], ("local" | "cloudflare" | "globalping")[]>>>>;
            health_check_aggregate: z.ZodCatch<z.ZodEnum<{
                any: "any";
                all: "all";
                majority: "majority";
            }>>;
            cert_monitoring: z.ZodDefault<z.ZodEnum<{
                auto: "auto";
                required: "required";
                skipped: "skipped";
            }>>;
            sync_status: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            active_ips: z.ZodDefault<z.ZodArray<z.ZodString>>;
        }, z.core.$strip>, z.ZodTransform<{
            target_ips: string[];
            target_ip_weights: Record<string, number>;
            target_ip_priorities: Record<string, number>;
            target_cname: string | null;
            record_type: "A" | "CNAME";
            binding_id: number;
            domain_id: number;
            zone_name: string;
            hostname: string;
            fqdn: string;
            lb_mode: "round_robin" | "failover" | "weighted";
            health_check_enabled: boolean;
            health_check_type: "tcp" | "http" | "ping" | "dns";
            health_check_port: number | null;
            health_check_path: string | null;
            health_check_expected_status: number | null;
            health_check_interval_sec: number;
            health_check_timeout_ms: number;
            health_check_verify_tls: boolean;
            health_check_provider: "local" | "cloudflare" | "globalping";
            health_check_providers: ("local" | "cloudflare" | "globalping")[] | readonly ["local"];
            health_check_aggregate: "any" | "all" | "majority";
            cert_monitoring: "auto" | "required" | "skipped";
            sync_status: string | null;
            active_ips: string[];
            target_ip?: string | null | undefined;
        }, {
            binding_id: number;
            domain_id: number;
            zone_name: string;
            hostname: string;
            fqdn: string;
            record_type: "A" | "CNAME";
            lb_mode: "round_robin" | "failover" | "weighted";
            health_check_enabled: boolean;
            health_check_type: "tcp" | "http" | "ping" | "dns";
            health_check_port: number | null;
            health_check_path: string | null;
            health_check_expected_status: number | null;
            health_check_interval_sec: number;
            health_check_timeout_ms: number;
            health_check_verify_tls: boolean;
            health_check_provider: "local" | "cloudflare" | "globalping";
            health_check_providers: ("local" | "cloudflare" | "globalping")[] | readonly ["local"];
            health_check_aggregate: "any" | "all" | "majority";
            cert_monitoring: "auto" | "required" | "skipped";
            sync_status: string | null;
            active_ips: string[];
            target_ips?: string[] | undefined;
            target_ip?: string | null | undefined;
            target_ip_weights?: Record<string, number> | undefined;
            target_ip_priorities?: Record<string, number> | undefined;
            target_cname?: string | null | undefined;
        }>>>>;
        health_status: z.ZodDefault<z.ZodEnum<{
            unknown: "unknown";
            up: "up";
            down: "down";
            degraded: "degraded";
        }>>;
        health_latency_ms: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
        ip_health: z.ZodDefault<z.ZodArray<z.ZodObject<{
            ip: z.ZodString;
            status: z.ZodEnum<{
                unknown: "unknown";
                up: "up";
                down: "down";
                degraded: "degraded";
            }>;
            latency_ms: z.ZodNullable<z.ZodNumber>;
            last_checked_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            last_error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            provider: z.ZodOptional<z.ZodEnum<{
                local: "local";
                cloudflare: "cloudflare";
                globalping: "globalping";
                aggregate: "aggregate";
            }>>;
            colo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        }, z.core.$strip>>>;
        ip_enabled: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
        lb_mode: z.ZodCatch<z.ZodEnum<{
            round_robin: "round_robin";
            failover: "failover";
            weighted: "weighted";
        }>>;
        active_ips: z.ZodDefault<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>>>;
}, z.core.$strip>;
declare const domainSchema: z.ZodObject<{
    id: z.ZodNumber;
    group_id: z.ZodNullable<z.ZodNumber>;
    zone_name: z.ZodString;
    cf_zone_id: z.ZodString;
    status: z.ZodString;
    cert_monitoring: z.ZodDefault<z.ZodEnum<{
        auto: "auto";
        required: "required";
        skipped: "skipped";
    }>>;
    environment: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
        prod: "prod";
        staging: "staging";
        dev: "dev";
    }>>>>;
    last_synced_at: z.ZodNullable<z.ZodString>;
    created_at: z.ZodString;
    updated_at: z.ZodString;
}, z.core.$strip>;
declare const domainListItemSchema: z.ZodObject<{
    id: z.ZodNumber;
    group_id: z.ZodNullable<z.ZodNumber>;
    zone_name: z.ZodString;
    cf_zone_id: z.ZodString;
    status: z.ZodString;
    cert_monitoring: z.ZodDefault<z.ZodEnum<{
        auto: "auto";
        required: "required";
        skipped: "skipped";
    }>>;
    environment: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
        prod: "prod";
        staging: "staging";
        dev: "dev";
    }>>>>;
    last_synced_at: z.ZodNullable<z.ZodString>;
    created_at: z.ZodString;
    updated_at: z.ZodString;
    group_name: z.ZodNullable<z.ZodString>;
    service_count: z.ZodNumber;
    health_status: z.ZodDefault<z.ZodEnum<{
        unknown: "unknown";
        up: "up";
        down: "down";
        degraded: "degraded";
    }>>;
    health_latency_ms: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
}, z.core.$strip>;
declare const serviceBindingSchema: z.ZodPipe<z.ZodObject<{
    id: z.ZodNumber;
    domain_id: z.ZodNumber;
    service_id: z.ZodNumber;
    hostname: z.ZodString;
    dns_record_id: z.ZodNullable<z.ZodNumber>;
    zone_name: z.ZodString;
    group_id: z.ZodNullable<z.ZodNumber>;
    group_name: z.ZodNullable<z.ZodString>;
    service_name: z.ZodString;
    service_slug: z.ZodString;
    target_ip: z.ZodNullable<z.ZodString>;
    target_ips: z.ZodOptional<z.ZodArray<z.ZodString>>;
    target_ip_weights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodCoercedNumber<unknown>>>;
    target_ip_priorities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodCoercedNumber<unknown>>>;
    lb_mode: z.ZodCatch<z.ZodEnum<{
        round_robin: "round_robin";
        failover: "failover";
        weighted: "weighted";
    }>>;
    health_check_enabled: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
    health_check_type: z.ZodCatch<z.ZodEnum<{
        tcp: "tcp";
        http: "http";
        ping: "ping";
        dns: "dns";
    }>>;
    health_check_port: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
    health_check_path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
    health_check_expected_status: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
    health_check_interval_sec: z.ZodDefault<z.ZodNumber>;
    health_check_timeout_ms: z.ZodDefault<z.ZodNumber>;
    health_check_verify_tls: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
    cert_monitoring: z.ZodDefault<z.ZodEnum<{
        auto: "auto";
        required: "required";
        skipped: "skipped";
    }>>;
    sync_status: z.ZodDefault<z.ZodNullable<z.ZodString>>;
    created_at: z.ZodString;
    updated_at: z.ZodString;
}, z.core.$strip>, z.ZodTransform<{
    target_ips: string[];
    target_ip_weights: Record<string, number>;
    target_ip_priorities: Record<string, number>;
    id: number;
    domain_id: number;
    service_id: number;
    hostname: string;
    dns_record_id: number | null;
    zone_name: string;
    group_id: number | null;
    group_name: string | null;
    service_name: string;
    service_slug: string;
    target_ip: string | null;
    lb_mode: "round_robin" | "failover" | "weighted";
    health_check_enabled: boolean;
    health_check_type: "tcp" | "http" | "ping" | "dns";
    health_check_port: number | null;
    health_check_path: string | null;
    health_check_expected_status: number | null;
    health_check_interval_sec: number;
    health_check_timeout_ms: number;
    health_check_verify_tls: boolean;
    cert_monitoring: "auto" | "required" | "skipped";
    sync_status: string | null;
    created_at: string;
    updated_at: string;
}, {
    id: number;
    domain_id: number;
    service_id: number;
    hostname: string;
    dns_record_id: number | null;
    zone_name: string;
    group_id: number | null;
    group_name: string | null;
    service_name: string;
    service_slug: string;
    target_ip: string | null;
    lb_mode: "round_robin" | "failover" | "weighted";
    health_check_enabled: boolean;
    health_check_type: "tcp" | "http" | "ping" | "dns";
    health_check_port: number | null;
    health_check_path: string | null;
    health_check_expected_status: number | null;
    health_check_interval_sec: number;
    health_check_timeout_ms: number;
    health_check_verify_tls: boolean;
    cert_monitoring: "auto" | "required" | "skipped";
    sync_status: string | null;
    created_at: string;
    updated_at: string;
    target_ips?: string[] | undefined;
    target_ip_weights?: Record<string, number> | undefined;
    target_ip_priorities?: Record<string, number> | undefined;
}>>;
declare const dnsRecordSchema: z.ZodObject<{
    id: z.ZodNumber;
    domain_id: z.ZodNumber;
    cf_record_id: z.ZodNullable<z.ZodString>;
    record_type: z.ZodString;
    name: z.ZodString;
    content: z.ZodString;
    ttl: z.ZodNumber;
    proxied: z.ZodBoolean;
    priority: z.ZodNullable<z.ZodNumber>;
    sync_status: z.ZodString;
    origin: z.ZodString;
    last_error: z.ZodNullable<z.ZodString>;
    created_at: z.ZodString;
    updated_at: z.ZodString;
}, z.core.$strip>;
declare const certificateSchema: z.ZodObject<{
    id: z.ZodNumber;
    domain_id: z.ZodNumber;
    subdomain_id: z.ZodNullable<z.ZodNumber>;
    service_id: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodNumber>>>;
    service_name: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
    hostname: z.ZodString;
    expires_at: z.ZodNullable<z.ZodString>;
    last_checked_at: z.ZodNullable<z.ZodString>;
    last_error: z.ZodNullable<z.ZodString>;
    status: z.ZodString;
    created_at: z.ZodString;
    updated_at: z.ZodString;
}, z.core.$strip>;
declare const serviceCertificateRowSchema: z.ZodObject<{
    binding_id: z.ZodNumber;
    domain_id: z.ZodNumber;
    service_id: z.ZodNumber;
    hostname: z.ZodString;
    cert_monitoring: z.ZodEnum<{
        auto: "auto";
        required: "required";
        skipped: "skipped";
    }>;
    id: z.ZodNullable<z.ZodNumber>;
    status: z.ZodString;
    expires_at: z.ZodNullable<z.ZodString>;
    last_checked_at: z.ZodNullable<z.ZodString>;
    last_error: z.ZodNullable<z.ZodString>;
}, z.core.$strip>;
type Group = z.infer<typeof groupSchema>;
type GroupWithStats = z.infer<typeof groupWithStatsSchema>;
type Service = z.infer<typeof serviceSchema>;
type ServiceDomainBinding = z.infer<typeof serviceDomainBindingSchema>;
type ServiceView = z.infer<typeof serviceViewSchema>;
type ServiceGroup = z.infer<typeof serviceGroupSchema>;
type ServiceGroupView = z.infer<typeof serviceGroupViewSchema>;
type ServiceGroupsResponse = z.infer<typeof serviceGroupsResponseSchema>;
type Domain = z.infer<typeof domainSchema>;
type DomainListItem = z.infer<typeof domainListItemSchema>;
type DnsRecord = z.infer<typeof dnsRecordSchema>;
type Certificate = z.infer<typeof certificateSchema>;
type ServiceCertificateRow = z.infer<typeof serviceCertificateRowSchema>;
declare const createGroupSchema: z.ZodObject<{
    name: z.ZodString;
    slug: z.ZodString;
}, z.core.$strip>;
declare const healthCheckConfigSchema: z.ZodObject<{
    health_check_enabled: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
    health_check_type: z.ZodOptional<z.ZodEnum<{
        tcp: "tcp";
        http: "http";
        ping: "ping";
        dns: "dns";
    }>>;
    health_check_port: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    health_check_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    health_check_expected_status: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    health_check_interval_sec: z.ZodOptional<z.ZodNumber>;
    health_check_timeout_ms: z.ZodOptional<z.ZodNumber>;
    health_check_verify_tls: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
    health_check_provider: z.ZodOptional<z.ZodEnum<{
        local: "local";
        cloudflare: "cloudflare";
        globalping: "globalping";
    }>>;
    health_check_providers: z.ZodOptional<z.ZodPreprocess<z.ZodPipe<z.ZodArray<z.ZodEnum<{
        local: "local";
        cloudflare: "cloudflare";
        globalping: "globalping";
    }>>, z.ZodTransform<("local" | "cloudflare" | "globalping")[] | readonly ["local"], ("local" | "cloudflare" | "globalping")[]>>>>;
    health_check_aggregate: z.ZodOptional<z.ZodEnum<{
        any: "any";
        all: "all";
        majority: "majority";
    }>>;
}, z.core.$strip>;
type HealthCheckConfig = z.infer<typeof healthCheckConfigSchema>;
declare const createServiceSchema: z.ZodObject<{
    name: z.ZodString;
    slug: z.ZodString;
}, z.core.$strip>;
declare const createServiceWithConfigSchema: z.ZodObject<{
    name: z.ZodString;
    slug: z.ZodString;
    service_group_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    ips: z.ZodDefault<z.ZodArray<z.ZodString>>;
    lb_weight: z.ZodOptional<z.ZodNumber>;
    lb_priority: z.ZodOptional<z.ZodNumber>;
    domains: z.ZodDefault<z.ZodArray<z.ZodObject<{
        health_check_enabled: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
        health_check_type: z.ZodOptional<z.ZodEnum<{
            tcp: "tcp";
            http: "http";
            ping: "ping";
            dns: "dns";
        }>>;
        health_check_port: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        health_check_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        health_check_expected_status: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        health_check_interval_sec: z.ZodOptional<z.ZodNumber>;
        health_check_timeout_ms: z.ZodOptional<z.ZodNumber>;
        health_check_verify_tls: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
        health_check_provider: z.ZodOptional<z.ZodEnum<{
            local: "local";
            cloudflare: "cloudflare";
            globalping: "globalping";
        }>>;
        health_check_providers: z.ZodOptional<z.ZodPreprocess<z.ZodPipe<z.ZodArray<z.ZodEnum<{
            local: "local";
            cloudflare: "cloudflare";
            globalping: "globalping";
        }>>, z.ZodTransform<("local" | "cloudflare" | "globalping")[] | readonly ["local"], ("local" | "cloudflare" | "globalping")[]>>>>;
        health_check_aggregate: z.ZodOptional<z.ZodEnum<{
            any: "any";
            all: "all";
            majority: "majority";
        }>>;
        fqdn: z.ZodString;
        target_ips: z.ZodOptional<z.ZodArray<z.ZodString>>;
        target_cname: z.ZodOptional<z.ZodString>;
        target_ip_weights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
        target_ip_priorities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
        lb_mode: z.ZodOptional<z.ZodEnum<{
            round_robin: "round_robin";
            failover: "failover";
            weighted: "weighted";
        }>>;
    }, z.core.$strip>>>;
}, z.core.$strip>;
declare const createServiceBindingSchema: z.ZodObject<{
    domain_id: z.ZodString;
    service_id: z.ZodString;
    hostname: z.ZodOptional<z.ZodString>;
    target_ip: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
declare const updateDomainGroupSchema: z.ZodObject<{
    group_id: z.ZodNullable<z.ZodNumber>;
    status: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
declare const createDomainSchema: z.ZodObject<{
    zone_name: z.ZodString;
    group_id: z.ZodString;
}, z.core.$strip>;
declare const loginSchema: z.ZodObject<{
    username: z.ZodString;
    password: z.ZodString;
}, z.core.$strip>;
declare const createDnsRecordSchema: z.ZodObject<{
    record_type: z.ZodEnum<{
        A: "A";
        CNAME: "CNAME";
        AAAA: "AAAA";
        TXT: "TXT";
        MX: "MX";
    }>;
    name: z.ZodString;
    content: z.ZodString;
    ttl: z.ZodNumber;
    proxied: z.ZodBoolean;
}, z.core.$strip>;
declare const subdomainSchema: z.ZodObject<{
    id: z.ZodNumber;
    domain_id: z.ZodNumber;
    name: z.ZodString;
    fqdn: z.ZodString;
    enabled: z.ZodBoolean;
    cert_monitoring: z.ZodDefault<z.ZodEnum<{
        auto: "auto";
        required: "required";
        skipped: "skipped";
    }>>;
    created_at: z.ZodString;
    updated_at: z.ZodString;
}, z.core.$strip>;
type SubdomainRecord = z.infer<typeof subdomainSchema>;
declare const createSubdomainSchema: z.ZodObject<{
    name: z.ZodString;
}, z.core.$strip>;
declare const updateSubdomainSchema: z.ZodObject<{
    name: z.ZodOptional<z.ZodString>;
    enabled: z.ZodOptional<z.ZodBoolean>;
    cert_monitoring: z.ZodOptional<z.ZodEnum<{
        auto: "auto";
        required: "required";
        skipped: "skipped";
    }>>;
}, z.core.$strip>;
declare const updateDomainSchema: z.ZodObject<{
    group_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    status: z.ZodOptional<z.ZodString>;
    cert_monitoring: z.ZodOptional<z.ZodEnum<{
        auto: "auto";
        required: "required";
        skipped: "skipped";
    }>>;
    environment: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
        prod: "prod";
        staging: "staging";
        dev: "dev";
    }>>>;
    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$strip>;
declare const bulkUpdateDomainsSchema: z.ZodObject<{
    ids: z.ZodArray<z.ZodNumber>;
    group_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    environment: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
        prod: "prod";
        staging: "staging";
        dev: "dev";
    }>>>;
    tags_add: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$strip>;
type BulkUpdateDomainsInput = z.infer<typeof bulkUpdateDomainsSchema>;
declare const domainMonitorSchema: z.ZodObject<{
    id: z.ZodNumber;
    domain_id: z.ZodNumber;
    hostname: z.ZodString;
    type: z.ZodEnum<{
        http: "http";
        ping: "ping";
        dns: "dns";
    }>;
    enabled: z.ZodCoercedBoolean<unknown>;
    interval_sec: z.ZodNumber;
    timeout_ms: z.ZodNumber;
    path: z.ZodNullable<z.ZodString>;
    expected_status: z.ZodNullable<z.ZodNumber>;
    last_status: z.ZodDefault<z.ZodEnum<{
        unknown: "unknown";
        up: "up";
        down: "down";
        degraded: "degraded";
    }>>;
    last_latency_ms: z.ZodNullable<z.ZodNumber>;
    last_checked_at: z.ZodNullable<z.ZodString>;
    last_error: z.ZodNullable<z.ZodString>;
    created_at: z.ZodString;
    updated_at: z.ZodString;
}, z.core.$strip>;
type DomainMonitor = z.infer<typeof domainMonitorSchema>;
declare const createDomainMonitorSchema: z.ZodObject<{
    hostname: z.ZodString;
    type: z.ZodEnum<{
        http: "http";
        ping: "ping";
        dns: "dns";
    }>;
    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    interval_sec: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    timeout_ms: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    expected_status: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
}, z.core.$strip>;
type CreateDomainMonitorInput = z.infer<typeof createDomainMonitorSchema>;
declare const domainMonitorResultSchema: z.ZodObject<{
    id: z.ZodNumber;
    monitor_id: z.ZodNumber;
    status: z.ZodEnum<{
        unknown: "unknown";
        up: "up";
        down: "down";
        degraded: "degraded";
    }>;
    latency_ms: z.ZodNullable<z.ZodNumber>;
    error: z.ZodNullable<z.ZodString>;
    checked_at: z.ZodString;
}, z.core.$strip>;
type DomainMonitorResult = z.infer<typeof domainMonitorResultSchema>;
declare const notificationLogSchema: z.ZodObject<{
    id: z.ZodNumber;
    kind: z.ZodString;
    ref_type: z.ZodString;
    ref_id: z.ZodNullable<z.ZodNumber>;
    title: z.ZodString;
    message: z.ZodString;
    created_at: z.ZodString;
}, z.core.$strip>;
type NotificationLog = z.infer<typeof notificationLogSchema>;
type CreateSubdomainInput = z.infer<typeof createSubdomainSchema>;
type UpdateSubdomainInput = z.infer<typeof updateSubdomainSchema>;
type UpdateDomainInput = z.infer<typeof updateDomainSchema>;
type CreateGroupInput = z.infer<typeof createGroupSchema>;
type CreateServiceInput = z.infer<typeof createServiceSchema>;
type CreateServiceWithConfigInput = z.infer<typeof createServiceWithConfigSchema>;
declare const updateServiceConfigSchema: z.ZodObject<{
    name: z.ZodOptional<z.ZodString>;
    slug: z.ZodOptional<z.ZodString>;
    service_group_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    ips: z.ZodOptional<z.ZodArray<z.ZodString>>;
    lb_weight: z.ZodOptional<z.ZodNumber>;
    lb_priority: z.ZodOptional<z.ZodNumber>;
    domains: z.ZodOptional<z.ZodArray<z.ZodObject<{
        health_check_enabled: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
        health_check_type: z.ZodOptional<z.ZodEnum<{
            tcp: "tcp";
            http: "http";
            ping: "ping";
            dns: "dns";
        }>>;
        health_check_port: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        health_check_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        health_check_expected_status: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        health_check_interval_sec: z.ZodOptional<z.ZodNumber>;
        health_check_timeout_ms: z.ZodOptional<z.ZodNumber>;
        health_check_verify_tls: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
        health_check_provider: z.ZodOptional<z.ZodEnum<{
            local: "local";
            cloudflare: "cloudflare";
            globalping: "globalping";
        }>>;
        health_check_providers: z.ZodOptional<z.ZodPreprocess<z.ZodPipe<z.ZodArray<z.ZodEnum<{
            local: "local";
            cloudflare: "cloudflare";
            globalping: "globalping";
        }>>, z.ZodTransform<("local" | "cloudflare" | "globalping")[] | readonly ["local"], ("local" | "cloudflare" | "globalping")[]>>>>;
        health_check_aggregate: z.ZodOptional<z.ZodEnum<{
            any: "any";
            all: "all";
            majority: "majority";
        }>>;
        fqdn: z.ZodString;
        target_ips: z.ZodOptional<z.ZodArray<z.ZodString>>;
        target_cname: z.ZodOptional<z.ZodString>;
        target_ip_weights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
        target_ip_priorities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
        lb_mode: z.ZodOptional<z.ZodEnum<{
            round_robin: "round_robin";
            failover: "failover";
            weighted: "weighted";
        }>>;
    }, z.core.$strip>>>;
}, z.core.$strip>;
type UpdateServiceConfigInput = z.infer<typeof updateServiceConfigSchema>;
declare const createServiceGroupSchema: z.ZodObject<{
    health_check_enabled: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
    health_check_type: z.ZodOptional<z.ZodEnum<{
        tcp: "tcp";
        http: "http";
        ping: "ping";
        dns: "dns";
    }>>;
    health_check_port: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    health_check_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    health_check_expected_status: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    health_check_interval_sec: z.ZodOptional<z.ZodNumber>;
    health_check_timeout_ms: z.ZodOptional<z.ZodNumber>;
    health_check_verify_tls: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
    health_check_provider: z.ZodOptional<z.ZodEnum<{
        local: "local";
        cloudflare: "cloudflare";
        globalping: "globalping";
    }>>;
    health_check_providers: z.ZodOptional<z.ZodPreprocess<z.ZodPipe<z.ZodArray<z.ZodEnum<{
        local: "local";
        cloudflare: "cloudflare";
        globalping: "globalping";
    }>>, z.ZodTransform<("local" | "cloudflare" | "globalping")[] | readonly ["local"], ("local" | "cloudflare" | "globalping")[]>>>>;
    health_check_aggregate: z.ZodOptional<z.ZodEnum<{
        any: "any";
        all: "all";
        majority: "majority";
    }>>;
    name: z.ZodString;
    type: z.ZodDefault<z.ZodEnum<{
        custom: "custom";
        vpn: "vpn";
        network: "network";
        internet: "internet";
        bgp: "bgp";
    }>>;
    icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    domain: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    lb_mode: z.ZodOptional<z.ZodEnum<{
        round_robin: "round_robin";
        failover: "failover";
        weighted: "weighted";
    }>>;
}, z.core.$strip>;
declare const updateServiceGroupSchema: z.ZodObject<{
    health_check_enabled: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
    health_check_type: z.ZodOptional<z.ZodEnum<{
        tcp: "tcp";
        http: "http";
        ping: "ping";
        dns: "dns";
    }>>;
    health_check_port: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    health_check_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    health_check_expected_status: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    health_check_interval_sec: z.ZodOptional<z.ZodNumber>;
    health_check_timeout_ms: z.ZodOptional<z.ZodNumber>;
    health_check_verify_tls: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
    health_check_provider: z.ZodOptional<z.ZodEnum<{
        local: "local";
        cloudflare: "cloudflare";
        globalping: "globalping";
    }>>;
    health_check_providers: z.ZodOptional<z.ZodPreprocess<z.ZodPipe<z.ZodArray<z.ZodEnum<{
        local: "local";
        cloudflare: "cloudflare";
        globalping: "globalping";
    }>>, z.ZodTransform<("local" | "cloudflare" | "globalping")[] | readonly ["local"], ("local" | "cloudflare" | "globalping")[]>>>>;
    health_check_aggregate: z.ZodOptional<z.ZodEnum<{
        any: "any";
        all: "all";
        majority: "majority";
    }>>;
    name: z.ZodOptional<z.ZodString>;
    type: z.ZodOptional<z.ZodEnum<{
        custom: "custom";
        vpn: "vpn";
        network: "network";
        internet: "internet";
        bgp: "bgp";
    }>>;
    icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    domain: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    lb_mode: z.ZodOptional<z.ZodEnum<{
        round_robin: "round_robin";
        failover: "failover";
        weighted: "weighted";
    }>>;
}, z.core.$strip>;
type UpdateServiceGroupInput = z.infer<typeof updateServiceGroupSchema>;
declare const toggleEnabledSchema: z.ZodObject<{
    enabled: z.ZodBoolean;
}, z.core.$strip>;
declare const toggleServiceIpSchema: z.ZodObject<{
    ip: z.ZodString;
    enabled: z.ZodBoolean;
}, z.core.$strip>;
type ToggleServiceIpInput = z.infer<typeof toggleServiceIpSchema>;
declare const reorderServicesSchema: z.ZodObject<{
    group_id: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>>>;
    service_ids: z.ZodArray<z.ZodNumber>;
}, z.core.$strip>;
declare const healthStatusQuerySchema: z.ZodObject<{
    scope: z.ZodEnum<{
        binding: "binding";
        group: "group";
    }>;
    ref_id: z.ZodCoercedNumber<unknown>;
}, z.core.$strip>;
type HealthStatusQuery = z.infer<typeof healthStatusQuerySchema>;
type CreateServiceGroupInput = z.infer<typeof createServiceGroupSchema>;
type ToggleEnabledInput = z.infer<typeof toggleEnabledSchema>;
type ReorderServicesInput = z.infer<typeof reorderServicesSchema>;
type CreateServiceBindingInput = z.infer<typeof createServiceBindingSchema>;
type CreateDomainInput = z.infer<typeof createDomainSchema>;
type LoginInput = z.infer<typeof loginSchema>;
type CreateDnsRecordInput = z.infer<typeof createDnsRecordSchema>;
declare const serviceNodeSchema: z.ZodObject<{
    id: z.ZodNumber;
    service_id: z.ZodNumber;
    address: z.ZodString;
    protocol: z.ZodString;
    port: z.ZodNullable<z.ZodNumber>;
    enabled: z.ZodCoercedBoolean<unknown>;
    priority: z.ZodNumber;
    weight: z.ZodNumber;
    health_status: z.ZodEnum<{
        unknown: "unknown";
        degraded: "degraded";
        checking: "checking";
        healthy: "healthy";
        unhealthy: "unhealthy";
        disabled: "disabled";
    }>;
    health_check_id: z.ZodNullable<z.ZodNumber>;
    consecutive_failures: z.ZodNumber;
    consecutive_successes: z.ZodNumber;
    last_check_at: z.ZodNullable<z.ZodString>;
    last_failure_reason: z.ZodNullable<z.ZodString>;
    created_at: z.ZodString;
    updated_at: z.ZodString;
}, z.core.$strip>;
declare const createServiceNodeSchema: z.ZodObject<{
    address: z.ZodString;
    protocol: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
        tcp: "tcp";
        http: "http";
        https: "https";
    }>>>;
    port: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    priority: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    weight: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    health_check_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
}, z.core.$strip>;
declare const updateServiceNodeSchema: z.ZodObject<{
    address: z.ZodOptional<z.ZodString>;
    protocol: z.ZodOptional<z.ZodDefault<z.ZodOptional<z.ZodEnum<{
        tcp: "tcp";
        http: "http";
        https: "https";
    }>>>>;
    port: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodNumber>>>;
    enabled: z.ZodOptional<z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
    priority: z.ZodOptional<z.ZodDefault<z.ZodOptional<z.ZodNumber>>>;
    weight: z.ZodOptional<z.ZodDefault<z.ZodOptional<z.ZodNumber>>>;
    health_check_id: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodNumber>>>;
}, z.core.$strip>;
declare const originHealthCheckSchema: z.ZodObject<{
    id: z.ZodNumber;
    provider: z.ZodEnum<{
        local: "local";
        cloudflare: "cloudflare";
        globalping: "globalping";
    }>;
    cf_healthcheck_id: z.ZodNullable<z.ZodString>;
    cf_zone_id: z.ZodNullable<z.ZodString>;
    name: z.ZodString;
    protocol: z.ZodString;
    path: z.ZodNullable<z.ZodString>;
    method: z.ZodNullable<z.ZodString>;
    timeout: z.ZodNumber;
    interval_sec: z.ZodNumber;
    retries: z.ZodNumber;
    expected_status: z.ZodNullable<z.ZodNumber>;
    consecutive_fails: z.ZodNumber;
    consecutive_successes: z.ZodNumber;
    suspended: z.ZodCoercedBoolean<unknown>;
    created_at: z.ZodString;
    updated_at: z.ZodString;
}, z.core.$strip>;
declare const createOriginHealthCheckSchema: z.ZodObject<{
    provider: z.ZodEnum<{
        local: "local";
        cloudflare: "cloudflare";
        globalping: "globalping";
    }>;
    name: z.ZodString;
    cf_zone_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    protocol: z.ZodOptional<z.ZodEnum<{
        tcp: "tcp";
        http: "http";
        https: "https";
        HTTP: "HTTP";
        HTTPS: "HTTPS";
        TCP: "TCP";
    }>>;
    path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    method: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    timeout: z.ZodOptional<z.ZodNumber>;
    interval_sec: z.ZodOptional<z.ZodNumber>;
    retries: z.ZodOptional<z.ZodNumber>;
    expected_status: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    consecutive_fails: z.ZodOptional<z.ZodNumber>;
    consecutive_successes: z.ZodOptional<z.ZodNumber>;
    suspended: z.ZodOptional<z.ZodBoolean>;
    node_id: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
declare const changeIpSchema: z.ZodObject<{
    from_ip: z.ZodOptional<z.ZodString>;
    to_ip: z.ZodOptional<z.ZodString>;
    node_id: z.ZodOptional<z.ZodNumber>;
    dry_run: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
}, z.core.$strip>;
declare const changeDomainSchema: z.ZodObject<{
    from_domain_id: z.ZodNumber;
    to_domain_id: z.ZodNumber;
    hostnames: z.ZodOptional<z.ZodArray<z.ZodString>>;
    dry_run: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
}, z.core.$strip>;
type ServiceNodeRecord = z.infer<typeof serviceNodeSchema>;
type CreateServiceNodeInput = z.infer<typeof createServiceNodeSchema>;
type UpdateServiceNodeInput = z.infer<typeof updateServiceNodeSchema>;
type OriginHealthCheckRecord = z.infer<typeof originHealthCheckSchema>;
type CreateOriginHealthCheckInput = z.infer<typeof createOriginHealthCheckSchema>;
type ChangeIpInput = z.infer<typeof changeIpSchema>;
type ChangeDomainInput = z.infer<typeof changeDomainSchema>;

declare const appSwitcherIconSchema: z.ZodEnum<{
    server: "server";
    cloud: "cloud";
    globe: "globe";
    dashboard: "dashboard";
    chart: "chart";
}>;
declare const appSwitcherEntrySchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    subtitle: z.ZodOptional<z.ZodString>;
    url: z.ZodString;
    icon: z.ZodDefault<z.ZodEnum<{
        server: "server";
        cloud: "cloud";
        globe: "globe";
        dashboard: "dashboard";
        chart: "chart";
    }>>;
    enabled: z.ZodOptional<z.ZodBoolean>;
    sort: z.ZodOptional<z.ZodNumber>;
    shortcut: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
declare const appSwitcherConfigSchema: z.ZodObject<{
    menuLabel: z.ZodDefault<z.ZodString>;
    apps: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        subtitle: z.ZodOptional<z.ZodString>;
        url: z.ZodString;
        icon: z.ZodDefault<z.ZodEnum<{
            server: "server";
            cloud: "cloud";
            globe: "globe";
            dashboard: "dashboard";
            chart: "chart";
        }>>;
        enabled: z.ZodOptional<z.ZodBoolean>;
        sort: z.ZodOptional<z.ZodNumber>;
        shortcut: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
}, z.core.$strip>;
type AppSwitcherEntry = z.infer<typeof appSwitcherEntrySchema>;
type AppSwitcherConfig = z.infer<typeof appSwitcherConfigSchema>;

declare const cfdmBindingSyncItemSchema: z.ZodObject<{
    bindingId: z.ZodNumber;
    serviceId: z.ZodNumber;
    serviceName: z.ZodString;
    serviceSlug: z.ZodString;
    fqdn: z.ZodString;
    zoneName: z.ZodString;
    hostname: z.ZodString;
    ips: z.ZodArray<z.ZodString>;
    cnameTarget: z.ZodOptional<z.ZodString>;
    deleted: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>;
declare const cfdmSyncBindingsBodySchema: z.ZodObject<{
    bindings: z.ZodArray<z.ZodObject<{
        bindingId: z.ZodNumber;
        serviceId: z.ZodNumber;
        serviceName: z.ZodString;
        serviceSlug: z.ZodString;
        fqdn: z.ZodString;
        zoneName: z.ZodString;
        hostname: z.ZodString;
        ips: z.ZodArray<z.ZodString>;
        cnameTarget: z.ZodOptional<z.ZodString>;
        deleted: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    fullSync: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>;
type CfdmBindingSyncItem = z.infer<typeof cfdmBindingSyncItemSchema>;
declare const appSettingsPatchSchema: z.ZodObject<{
    vpsTrackerUrl: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>>;
    vpsTrackerIntegrationToken: z.ZodOptional<z.ZodString>;
    vpsTrackerSyncEnabled: z.ZodOptional<z.ZodBoolean>;
    showQuickActions: z.ZodOptional<z.ZodBoolean>;
    healthCheckCron: z.ZodOptional<z.ZodString>;
    healthDegradedFailures: z.ZodOptional<z.ZodNumber>;
    healthDownFailures: z.ZodOptional<z.ZodNumber>;
    healthLatencyWarnMs: z.ZodOptional<z.ZodNumber>;
    healthSuccessRecoveries: z.ZodOptional<z.ZodNumber>;
    healthWorkerUrl: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>>;
    healthWorkerToken: z.ZodOptional<z.ZodString>;
    globalpingToken: z.ZodOptional<z.ZodString>;
    globalpingLocations: z.ZodOptional<z.ZodString>;
    globalpingLimit: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type AppSettingsPatch = z.infer<typeof appSettingsPatchSchema>;
declare const vpsTrackerEventSchema: z.ZodObject<{
    event: z.ZodEnum<{
        vps_down: "vps_down";
        vps_up: "vps_up";
    }>;
    vps: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        ip: z.ZodOptional<z.ZodString>;
        label: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
    timestamp: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type VpsTrackerEvent = z.infer<typeof vpsTrackerEventSchema>;

declare const HEALTH_PROBE_SCRIPT_NAME = "cfdm-health-probe";
declare const HEALTH_PROBE_KV_TITLE = "cfdm-health-probe";
declare const HEALTH_KV_TARGETS_KEY = "targets";
declare const HEALTH_KV_RESULTS_KEY = "results";
declare const HEALTH_KV_CURSOR_KEY = "cursor";
declare const HEALTH_PROBE_BATCH = 48;
declare const HEALTH_PROBE_CONCURRENCY = 5;
type HealthWorkerStatus = "missing" | "ready" | "error";
interface HealthProbeTargetItem {
    key: string;
    ip: string;
    hostname: string;
    type: "tcp" | "http";
    port: number;
    path?: string;
    expectedStatus?: number | null;
    timeoutMs?: number;
    verifyTls?: boolean;
}
interface HealthProbeTargetsDoc {
    fingerprint: string;
    updatedAt: string;
    items: HealthProbeTargetItem[];
}
interface HealthProbeResultItem {
    key: string;
    ok: boolean;
    latencyMs: number;
    error: string | null;
}
interface HealthProbeResultsDoc {
    probedAt: string;
    colo: string | null;
    fingerprint?: string;
    items: HealthProbeResultItem[];
}

declare const AUDIT_SEVERITIES: readonly ["info", "warning", "critical"];
type AuditSeverity = (typeof AUDIT_SEVERITIES)[number];
declare const auditSeveritySchema: z.ZodEnum<{
    warning: "warning";
    info: "info";
    critical: "critical";
}>;
declare const AUDIT_SOURCE_APPS: readonly ["portal", "vps", "cfdm", "bgp", "fw"];
type AuditSourceApp = (typeof AUDIT_SOURCE_APPS)[number];
declare const auditSourceAppSchema: z.ZodEnum<{
    bgp: "bgp";
    vps: "vps";
    portal: "portal";
    cfdm: "cfdm";
    fw: "fw";
}>;
declare const AUDIT_TARGET_TYPES: readonly ["user", "settings", "session", "system", "app_resource"];
type AuditTargetType = (typeof AUDIT_TARGET_TYPES)[number];
declare const auditTargetTypeSchema: z.ZodEnum<{
    user: "user";
    settings: "settings";
    session: "session";
    system: "system";
    app_resource: "app_resource";
}>;
declare const auditLogEntrySchema: z.ZodObject<{
    id: z.ZodString;
    event_id: z.ZodNullable<z.ZodString>;
    source_app: z.ZodEnum<{
        bgp: "bgp";
        vps: "vps";
        portal: "portal";
        cfdm: "cfdm";
        fw: "fw";
    }>;
    action: z.ZodString;
    severity: z.ZodEnum<{
        warning: "warning";
        info: "info";
        critical: "critical";
    }>;
    actor_user_id: z.ZodNullable<z.ZodString>;
    actor_email: z.ZodNullable<z.ZodString>;
    actor_name: z.ZodNullable<z.ZodString>;
    target_type: z.ZodNullable<z.ZodEnum<{
        user: "user";
        settings: "settings";
        session: "session";
        system: "system";
        app_resource: "app_resource";
    }>>;
    target_id: z.ZodNullable<z.ZodString>;
    summary: z.ZodString;
    details: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    ip: z.ZodNullable<z.ZodString>;
    created_at: z.ZodString;
}, z.core.$strip>;
type AuditLogEntry = z.infer<typeof auditLogEntrySchema>;
declare const auditListQuerySchema: z.ZodObject<{
    action: z.ZodOptional<z.ZodString>;
    severity: z.ZodOptional<z.ZodEnum<{
        warning: "warning";
        info: "info";
        critical: "critical";
    }>>;
    user_id: z.ZodOptional<z.ZodString>;
    source_app: z.ZodOptional<z.ZodEnum<{
        bgp: "bgp";
        vps: "vps";
        portal: "portal";
        cfdm: "cfdm";
        fw: "fw";
    }>>;
    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
}, z.core.$strip>;
type AuditListQuery = z.infer<typeof auditListQuerySchema>;
declare const ingestAuditEventSchema: z.ZodObject<{
    event_id: z.ZodString;
    source_app: z.ZodEnum<{
        bgp: "bgp";
        vps: "vps";
        cfdm: "cfdm";
        fw: "fw";
    }>;
    action: z.ZodString;
    severity: z.ZodOptional<z.ZodEnum<{
        warning: "warning";
        info: "info";
        critical: "critical";
    }>>;
    actor_user_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    actor_email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    actor_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    target_type: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
        user: "user";
        settings: "settings";
        session: "session";
        system: "system";
        app_resource: "app_resource";
    }>>>;
    target_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    summary: z.ZodString;
    details: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
    ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    created_at: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type IngestAuditEvent = z.infer<typeof ingestAuditEventSchema>;

export { AUDIT_SEVERITIES, AUDIT_SOURCE_APPS, AUDIT_TARGET_TYPES, type AppSettingsPatch, type AppSwitcherConfig, type AppSwitcherEntry, type AuditListQuery, type AuditLogEntry, type AuditSeverity, type AuditSourceApp, type AuditTargetType, type BulkUpdateDomainsInput, CERT_ERROR, CERT_EXPIRED, CERT_MONITORING_VALUES, CERT_MONITOR_AUTO, CERT_MONITOR_REQUIRED, CERT_MONITOR_SKIPPED, CERT_OK, CERT_UNKNOWN, CERT_WARNING, type CertMonitoring, type Certificate, type CfDnsRecord, type CfHealthCheck, type CfZone, type CfdmBindingSyncItem, type ChangeDomainInput, type ChangeIpInput, type CreateDnsRecordInput, type CreateDnsRecordPayload, type CreateDomainInput, type CreateDomainMonitorInput, type CreateGroupInput, type CreateOriginHealthCheckInput, type CreateServiceBindingInput, type CreateServiceGroupInput, type CreateServiceInput, type CreateServiceNodeInput, type CreateServiceWithConfigInput, type CreateSubdomainInput, type DnsRecord, type Domain, type DomainEnvironment, type DomainListItem, type DomainMonitor, type DomainMonitorResult, type DomainMonitorType, type FailoverLogEntry, type Group, type GroupWithStats, HEALTH_CHECK_AGGREGATES, HEALTH_CHECK_PROVIDERS, HEALTH_KV_CURSOR_KEY, HEALTH_KV_RESULTS_KEY, HEALTH_KV_TARGETS_KEY, HEALTH_PROBE_BATCH, HEALTH_PROBE_CONCURRENCY, HEALTH_PROBE_KV_TITLE, HEALTH_PROBE_SCRIPT_NAME, HEALTH_STATUS_PROVIDERS, type HealthCheckAggregate, type HealthCheckConfig, type HealthCheckProvider, type HealthCheckScope, type HealthCheckTarget, type HealthCheckType, type HealthProbeLog, type HealthProbeResultItem, type HealthProbeResultsDoc, type HealthProbeTargetItem, type HealthProbeTargetsDoc, type HealthStatusProvider, type HealthStatusQuery, type HealthWorkerStatus, type IngestAuditEvent, type IpHealthState, type IpHealthStatus, type JwtClaims, type LbMode, type LoginInput, type LoginRequest, type LoginResponse, type NodeHealthState, type NotificationLog, type OriginHealthCheck, type OriginHealthCheckRecord, type ParsedFqdn, type PatchDnsRecordPayload, type ReorderServicesInput, SYNC_CONFLICT, SYNC_ERROR, SYNC_PENDING_DELETE, SYNC_PENDING_PUSH, SYNC_SYNCED, type Service, type ServiceBinding, type ServiceBindingView, type ServiceCertificateRow, type ServiceDomainBinding, type ServiceDomainBindingView, type ServiceGroup, type ServiceGroupView, type ServiceGroupsResponse, type ServiceIpHealth, type ServiceNode, type ServiceNodeRecord, type ServiceOverview, type ServiceView, type Subdomain, type SubdomainRecord, type SyncJob, type ToggleEnabledInput, type ToggleServiceIpInput, type UpdateDomainInput, type UpdateServiceConfigInput, type UpdateServiceGroupInput, type UpdateServiceNodeInput, type UpdateSubdomainInput, ValidationError, type VpsTrackerEvent, aggregateHealthOk, appSettingsPatchSchema, appSwitcherConfigSchema, appSwitcherEntrySchema, appSwitcherIconSchema, auditListQuerySchema, auditLogEntrySchema, auditSeveritySchema, auditSourceAppSchema, auditTargetTypeSchema, bindingToFqdn, bulkUpdateDomainsSchema, certMonitoringSchema, certStatusFromExpiry, certificateSchema, cfdmBindingSyncItemSchema, cfdmSyncBindingsBodySchema, changeDomainSchema, changeIpSchema, clampGlobalpingLimit, createDnsRecordSchema, createDomainMonitorSchema, createDomainSchema, createGroupSchema, createOriginHealthCheckSchema, createServiceBindingSchema, createServiceGroupSchema, createServiceNodeSchema, createServiceSchema, createServiceWithConfigSchema, createSubdomainSchema, derivePrimaryProvider, dnsNameToSubdomainLabel, dnsRecordNamesMatch, dnsRecordSchema, domainEnvironmentSchema, domainListItemSchema, domainMonitorResultSchema, domainMonitorSchema, domainMonitorTypeSchema, domainSchema, failoverLogSchema, fqdnToDisplay, groupSchema, groupWithStatsSchema, healthCheckAggregateSchema, healthCheckConfigSchema, healthCheckProviderSchema, healthCheckProvidersSchema, healthCheckScopeSchema, healthCheckTypeSchema, healthProbeLogSchema, healthStatusProviderSchema, healthStatusQuerySchema, ingestAuditEventSchema, ipHealthStateSchema, ipHealthStatusSchema, isIpLiteral, isValidIpv4, lbModeSchema, loginSchema, nodeHealthStateSchema, normalizeDnsRecordName, normalizeProbeProvider, normalizeStatusProvider, notificationLogSchema, originHealthCheckSchema, parseFqdn, parseGlobalpingLocations, parseHealthAggregate, parseHealthProviders, reorderServicesSchema, serializeHealthProviders, serviceBindingSchema, serviceCertificateRowSchema, serviceDomainBindingSchema, serviceGroupSchema, serviceGroupTypeSchema, serviceGroupViewSchema, serviceGroupsResponseSchema, serviceIpHealthSchema, serviceNodeSchema, serviceSchema, serviceViewSchema, shouldMonitorService, subdomainLabelToFqdn, subdomainSchema, targetHasProvider, targetProviders, toggleEnabledSchema, toggleServiceIpSchema, uniqueHealthProviders, updateDomainGroupSchema, updateDomainSchema, updateServiceConfigSchema, updateServiceGroupSchema, updateServiceNodeSchema, updateSubdomainSchema, validateDnsRecord, vpsTrackerEventSchema };