typekro 0.3.0 → 0.4.0

package/dist/factories/cilium/types.d.ts

@@ -0,0 +1,1001 @@
+/**
+ * Cilium Ecosystem Type Definitions
+ *
+ * This module provides comprehensive type definitions for the Cilium ecosystem,
+ * including bootstrap composition configuration, CRD factory interfaces,
+ * and common types used across Cilium resources.
+ */
+import { TypeKroError } from '../../core/errors.js';
+/**
+ * Configuration interface for Cilium bootstrap composition
+ */
+export interface CiliumBootstrapConfig {
+    name: string;
+    namespace?: string;
+    version?: string;
+    cluster: {
+        name: string;
+        id: number;
+    };
+    networking?: {
+        ipam?: {
+            mode: 'kubernetes' | 'cluster-pool' | 'azure' | 'aws-eni' | 'crd';
+            operator?: {
+                clusterPoolIPv4PodCIDRList?: string[];
+                clusterPoolIPv6PodCIDRList?: string[];
+            };
+        };
+        kubeProxyReplacement?: 'disabled' | 'partial' | 'strict';
+        routingMode?: 'tunnel' | 'native';
+        tunnelProtocol?: 'vxlan' | 'geneve';
+        autoDirectNodeRoutes?: boolean;
+        endpointRoutes?: {
+            enabled?: boolean;
+        };
+        hostServices?: {
+            enabled?: boolean;
+            protocols?: ('tcp' | 'udp')[];
+        };
+        nodePort?: {
+            enabled?: boolean;
+            range?: string;
+        };
+        externalIPs?: {
+            enabled?: boolean;
+        };
+        hostPort?: {
+            enabled?: boolean;
+        };
+        loadBalancer?: {
+            algorithm?: 'random' | 'round_robin' | 'maglev';
+            mode?: 'snat' | 'dsr' | 'hybrid';
+            acceleration?: 'disabled' | 'native' | 'best-effort';
+        };
+    };
+    security?: {
+        encryption?: {
+            enabled?: boolean;
+            type?: 'wireguard' | 'ipsec';
+            nodeEncryption?: boolean;
+            wireguard?: {
+                userspaceFallback?: boolean;
+                persistentKeepalive?: number;
+            };
+            ipsec?: {
+                interface?: string;
+                mountPath?: string;
+                keyFile?: string;
+            };
+        };
+        authentication?: {
+            enabled?: boolean;
+            mutual?: {
+                spire?: {
+                    enabled?: boolean;
+                    install?: boolean;
+                };
+            };
+        };
+        policyEnforcement?: 'default' | 'always' | 'never';
+        policyAuditMode?: boolean;
+    };
+    bgp?: {
+        enabled?: boolean;
+        announce?: {
+            loadbalancerIP?: boolean;
+            podCIDR?: boolean;
+        };
+    };
+    gatewayAPI?: {
+        enabled?: boolean;
+        secretsNamespace?: {
+            create?: boolean;
+            name?: string;
+        };
+    };
+    observability?: {
+        hubble?: {
+            enabled?: boolean;
+            metrics?: {
+                enabled?: string[];
+                enableOpenMetrics?: boolean;
+                port?: number;
+            };
+            relay?: {
+                enabled?: boolean;
+                replicas?: number;
+            };
+            ui?: {
+                enabled?: boolean;
+                replicas?: number;
+                ingress?: {
+                    enabled?: boolean;
+                    hosts?: string[];
+                };
+            };
+        };
+        prometheus?: {
+            enabled?: boolean;
+            port?: number;
+            serviceMonitor?: {
+                enabled?: boolean;
+            };
+        };
+    };
+    operator?: {
+        replicas?: number;
+        resources?: ResourceRequirements;
+    };
+    agent?: {
+        resources?: ResourceRequirements;
+    };
+    advanced?: {
+        bpf?: {
+            preallocateMaps?: boolean;
+            mapDynamicSizeRatio?: number;
+        };
+        k8s?: {
+            requireIPv4PodCIDR?: boolean;
+            requireIPv6PodCIDR?: boolean;
+        };
+        cni?: {
+            binPath?: string;
+            confPath?: string;
+        };
+    };
+    customValues?: Record<string, any>;
+    id?: string;
+}
+/**
+ * Status interface for Cilium bootstrap composition
+ */
+export interface CiliumBootstrapStatus {
+    phase: 'Installing' | 'Ready' | 'Failed' | 'Upgrading';
+    ready: boolean;
+    version: string;
+    agentReady: boolean;
+    operatorReady: boolean;
+    hubbleReady: boolean;
+    encryptionEnabled: boolean;
+    bgpEnabled: boolean;
+    gatewayAPIEnabled: boolean;
+    clusterMeshReady: boolean;
+    endpoints: {
+        health: string;
+        metrics: string;
+        hubbleMetrics?: string;
+        hubbleUI?: string;
+    };
+    cni: {
+        configPath: string;
+        socketPath: string;
+        binPath: string;
+    };
+    networking: {
+        ipamMode: string;
+        kubeProxyReplacement: string;
+        routingMode: string;
+        tunnelProtocol?: string;
+    };
+    security: {
+        policyEnforcement: string;
+        encryptionStatus: string;
+        authenticationEnabled: boolean;
+    };
+    resources: {
+        totalNodes: number;
+        readyNodes: number;
+        totalEndpoints: number;
+        totalIdentities: number;
+    };
+}
+/**
+ * Simple configuration interface for CiliumNetworkPolicy
+ */
+export interface CiliumNetworkPolicyConfig {
+    name: string;
+    namespace?: string;
+    spec: CiliumNetworkPolicySpec;
+    id?: string;
+}
+/**
+ * Simple configuration interface for CiliumClusterwideNetworkPolicy
+ */
+export interface CiliumClusterwideNetworkPolicyConfig {
+    name: string;
+    spec: CiliumClusterwideNetworkPolicySpec;
+    id?: string;
+}
+/**
+ * CiliumNetworkPolicy CRD type (following @kubernetes/client-node pattern)
+ */
+export interface CiliumNetworkPolicy {
+    apiVersion: 'cilium.io/v2';
+    kind: 'CiliumNetworkPolicy';
+    metadata: {
+        name: string;
+        namespace?: string;
+        labels?: Record<string, string>;
+        annotations?: Record<string, string>;
+        [key: string]: any;
+    };
+    spec: CiliumNetworkPolicySpec;
+    status?: CiliumNetworkPolicyStatus;
+    id?: string;
+}
+/**
+ * CiliumClusterwideNetworkPolicy CRD type (following @kubernetes/client-node pattern)
+ */
+export interface CiliumClusterwideNetworkPolicy {
+    apiVersion: 'cilium.io/v2';
+    kind: 'CiliumClusterwideNetworkPolicy';
+    metadata: {
+        name: string;
+        labels?: Record<string, string>;
+        annotations?: Record<string, string>;
+        [key: string]: any;
+    };
+    spec: CiliumClusterwideNetworkPolicySpec;
+    status?: CiliumClusterwideNetworkPolicyStatus;
+    id?: string;
+}
+/**
+ * Configuration interface for CiliumBGPClusterConfig
+ */
+export interface CiliumBGPClusterConfigConfig {
+    name: string;
+    spec: {
+        nodeSelector?: LabelSelector;
+        bgpInstances: BGPInstance[];
+    };
+    id?: string;
+}
+/**
+ * Configuration interface for CiliumBGPPeeringPolicy (Legacy)
+ */
+export interface CiliumBGPPeeringPolicyConfig {
+    name: string;
+    spec: {
+        nodeSelector?: LabelSelector;
+        virtualRouters: VirtualRouter[];
+    };
+    id?: string;
+}
+/**
+ * Configuration interface for CiliumBGPAdvertisement
+ */
+export interface CiliumBGPAdvertisementConfig {
+    name: string;
+    spec: {
+        advertisements: Advertisement[];
+    };
+    id?: string;
+}
+/**
+ * Configuration interface for CiliumLoadBalancerIPPool
+ */
+export interface CiliumLoadBalancerIPPoolConfig {
+    name: string;
+    spec: {
+        cidrs: CIDRBlock[];
+        serviceSelector?: ServiceSelector;
+        disabled?: boolean;
+    };
+    id?: string;
+}
+/**
+ * Configuration interface for CiliumL2AnnouncementPolicy
+ */
+export interface CiliumL2AnnouncementPolicyConfig {
+    name: string;
+    spec: {
+        nodeSelector?: LabelSelector;
+        serviceSelector?: ServiceSelector;
+        loadBalancerIPs?: boolean;
+        externalIPs?: boolean;
+        interfaces?: string[];
+    };
+    id?: string;
+}
+/**
+ * Configuration interface for CiliumGatewayClassConfig
+ */
+export interface CiliumGatewayClassConfigConfig {
+    name: string;
+    spec: {
+        gatewayType?: 'dedicated' | 'shared';
+        deployment?: {
+            replicas?: number;
+            resources?: ResourceRequirements;
+        };
+    };
+    id?: string;
+}
+/**
+ * Configuration interface for CiliumEnvoyConfig
+ */
+export interface CiliumEnvoyConfigConfig {
+    name: string;
+    namespace?: string;
+    spec: {
+        services?: ServiceReference[];
+        backendServices?: BackendService[];
+        resources: EnvoyResource[];
+    };
+    id?: string;
+}
+/**
+ * Configuration interface for CiliumClusterwideEnvoyConfig
+ */
+export interface CiliumClusterwideEnvoyConfigConfig {
+    name: string;
+    spec: {
+        services?: ServiceReference[];
+        backendServices?: BackendService[];
+        resources: EnvoyResource[];
+    };
+    id?: string;
+}
+/**
+ * Configuration interface for CiliumEgressGatewayPolicy
+ */
+export interface CiliumEgressGatewayPolicyConfig {
+    name: string;
+    spec: {
+        selectors: EndpointSelector[];
+        destinationCIDRs: string[];
+        excludedCIDRs?: string[];
+        gatewayConfig: {
+            nodeSelector: LabelSelector;
+            interface?: string;
+        };
+    };
+    id?: string;
+}
+/**
+ * Configuration interface for CiliumLocalRedirectPolicy
+ */
+export interface CiliumLocalRedirectPolicyConfig {
+    name: string;
+    namespace?: string;
+    spec: {
+        redirectFrontend: LocalRedirectFrontend;
+        redirectBackend: LocalRedirectBackend;
+        skipRedirectFromBackend?: boolean;
+    };
+    id?: string;
+}
+/**
+ * Configuration interface for CiliumCIDRGroup
+ */
+export interface CiliumCIDRGroupConfig {
+    name: string;
+    spec: {
+        cidrs: CIDRBlock[];
+    };
+    id?: string;
+}
+/**
+ * Kubernetes label selector
+ */
+export interface LabelSelector {
+    matchLabels?: Record<string, string>;
+    matchExpressions?: LabelSelectorRequirement[];
+}
+/**
+ * Label selector requirement
+ */
+export interface LabelSelectorRequirement {
+    key: string;
+    operator: 'In' | 'NotIn' | 'Exists' | 'DoesNotExist';
+    values?: string[];
+}
+/**
+ * Kubernetes resource requirements
+ */
+export interface ResourceRequirements {
+    limits?: {
+        cpu?: string;
+        memory?: string;
+    };
+    requests?: {
+        cpu?: string;
+        memory?: string;
+    };
+}
+/**
+ * Endpoint selector for Cilium policies
+ */
+export interface EndpointSelector {
+    matchLabels?: Record<string, string>;
+    matchExpressions?: LabelSelectorRequirement[];
+}
+/**
+ * Ingress rule for network policies
+ */
+export interface IngressRule {
+    fromEndpoints?: EndpointSelector[];
+    fromCIDR?: string[];
+    fromCIDRSet?: CIDRRule[];
+    fromEntities?: string[];
+    fromGroups?: GroupSelector[];
+    toPorts?: PortRule[];
+    icmps?: ICMPRule[];
+    authentication?: AuthenticationMode;
+}
+/**
+ * Egress rule for network policies
+ */
+export interface EgressRule {
+    toEndpoints?: EndpointSelector[];
+    toCIDR?: string[];
+    toCIDRSet?: CIDRRule[];
+    toEntities?: string[];
+    toGroups?: GroupSelector[];
+    toFQDNs?: FQDNSelector[];
+    toPorts?: PortRule[];
+    icmps?: ICMPRule[];
+    authentication?: AuthenticationMode;
+}
+/**
+ * Port rule for network policies
+ */
+export interface PortRule {
+    ports?: PortProtocol[];
+    rules?: L7Rules;
+}
+/**
+ * Port and protocol specification
+ */
+export interface PortProtocol {
+    port?: string;
+    protocol?: 'TCP' | 'UDP' | 'SCTP' | 'ANY';
+}
+/**
+ * Layer 7 rules for network policies
+ */
+export interface L7Rules {
+    http?: HTTPRule[];
+    kafka?: KafkaRule[];
+    dns?: DNSRule[];
+    l7proto?: string;
+    l7?: PortRuleL7[];
+}
+/**
+ * HTTP rule for L7 policies
+ */
+export interface HTTPRule {
+    method?: string;
+    path?: string;
+    host?: string;
+    headers?: string[];
+}
+/**
+ * Kafka rule for L7 policies
+ */
+export interface KafkaRule {
+    role?: 'produce' | 'consume';
+    topic?: string;
+    clientID?: string;
+}
+/**
+ * DNS rule for L7 policies
+ */
+export interface DNSRule {
+    matchName?: string;
+    matchPattern?: string;
+}
+/**
+ * Generic L7 rule
+ */
+export interface PortRuleL7 {
+    [key: string]: string;
+}
+/**
+ * CIDR rule with optional generated fields
+ */
+export interface CIDRRule {
+    cidr: string;
+    except?: string[];
+    generated?: boolean;
+}
+/**
+ * Group selector for policies
+ */
+export interface GroupSelector {
+    [key: string]: string;
+}
+/**
+ * FQDN selector for egress policies
+ */
+export interface FQDNSelector {
+    matchName?: string;
+    matchPattern?: string;
+}
+/**
+ * ICMP rule for network policies
+ */
+export interface ICMPRule {
+    fields?: ICMPField[];
+}
+/**
+ * ICMP field specification
+ */
+export interface ICMPField {
+    family?: 'IPv4' | 'IPv6';
+    type?: number;
+    code?: number;
+}
+/**
+ * Authentication mode for policies
+ */
+export interface AuthenticationMode {
+    mode: 'required' | 'always' | 'never';
+}
+/**
+ * BGP instance configuration
+ */
+export interface BGPInstance {
+    name: string;
+    localASN: number;
+    routerID?: string;
+    peers?: BGPPeer[];
+}
+/**
+ * BGP peer configuration
+ */
+export interface BGPPeer {
+    name: string;
+    peerASN: number;
+    peerAddress: string;
+    peerPort?: number;
+    multihop?: number;
+    connectRetryTimeSeconds?: number;
+    holdTimeSeconds?: number;
+    keepAliveTimeSeconds?: number;
+    gracefulRestart?: GracefulRestartConfig;
+    families?: AddressFamily[];
+}
+/**
+ * BGP graceful restart configuration
+ */
+export interface GracefulRestartConfig {
+    enabled?: boolean;
+    restartTimeSeconds?: number;
+    staleRoutesTimeSeconds?: number;
+}
+/**
+ * BGP address family
+ */
+export interface AddressFamily {
+    afi: 'ipv4' | 'ipv6';
+    safi: 'unicast' | 'multicast';
+    advertisements?: {
+        matchLabels?: Record<string, string>;
+        matchExpressions?: LabelSelectorRequirement[];
+    };
+}
+/**
+ * Virtual router configuration (legacy BGP)
+ */
+export interface VirtualRouter {
+    localASN: number;
+    exportPodCIDR?: boolean;
+    neighbors: BGPNeighbor[];
+    serviceSelector?: ServiceSelector;
+    podIPPoolSelector?: LabelSelector;
+}
+/**
+ * BGP neighbor configuration (legacy)
+ */
+export interface BGPNeighbor {
+    peerAddress: string;
+    peerASN: number;
+    peerPort?: number;
+    holdTimeSeconds?: number;
+    keepAliveTimeSeconds?: number;
+    connectRetryTimeSeconds?: number;
+    gracefulRestart?: {
+        enabled?: boolean;
+        restartTimeSeconds?: number;
+    };
+    families?: {
+        ipv4?: {
+            advertisements?: {
+                matchLabels?: Record<string, string>;
+            };
+        };
+        ipv6?: {
+            advertisements?: {
+                matchLabels?: Record<string, string>;
+            };
+        };
+    };
+}
+/**
+ * BGP advertisement configuration
+ */
+export interface Advertisement {
+    advertisementType: 'PodCIDR' | 'CiliumPodIPPool' | 'CiliumLoadBalancerIPPool' | 'Service';
+    selector?: LabelSelector;
+    service?: {
+        addresses?: ('ClusterIP' | 'ExternalIP' | 'LoadBalancerIP')[];
+    };
+    attributes?: {
+        localPreference?: number;
+        communities?: {
+            standard?: string[];
+            large?: string[];
+        };
+    };
+}
+/**
+ * CIDR block specification
+ */
+export interface CIDRBlock {
+    cidr: string;
+}
+/**
+ * Service selector for load balancer resources
+ */
+export interface ServiceSelector {
+    matchLabels?: Record<string, string>;
+    matchExpressions?: LabelSelectorRequirement[];
+}
+/**
+ * Service reference for Gateway API
+ */
+export interface ServiceReference {
+    name: string;
+    namespace?: string;
+}
+/**
+ * Backend service configuration
+ */
+export interface BackendService {
+    name: string;
+    namespace?: string;
+    ports?: string[];
+}
+/**
+ * Envoy resource configuration
+ */
+export interface EnvoyResource {
+    '@type': string;
+    [key: string]: any;
+}
+/**
+ * Local redirect frontend configuration
+ */
+export interface LocalRedirectFrontend {
+    addressMatcher: {
+        ip: string;
+        toPorts?: PortMatcher[];
+    };
+}
+/**
+ * Local redirect backend configuration
+ */
+export interface LocalRedirectBackend {
+    localEndpointSelector: EndpointSelector;
+    toPorts?: PortMatcher[];
+}
+/**
+ * Port matcher for local redirect policies
+ */
+export interface PortMatcher {
+    port: string;
+    protocol?: 'TCP' | 'UDP';
+    name?: string;
+}
+/**
+ * CiliumNetworkPolicy spec interface
+ */
+export interface CiliumNetworkPolicySpec {
+    endpointSelector?: LabelSelector;
+    ingress?: IngressRule[];
+    egress?: EgressRule[];
+    labels?: LabelSelector[];
+    description?: string;
+}
+/**
+ * CiliumNetworkPolicy status interface
+ */
+export interface CiliumNetworkPolicyStatus {
+    conditions?: Condition[];
+    state?: string;
+    message?: string;
+    nodes?: {
+        [nodeName: string]: {
+            ok?: boolean;
+            error?: string;
+            lastUpdated?: string;
+        };
+    };
+}
+/**
+ * CiliumClusterwideNetworkPolicy spec interface
+ */
+export interface CiliumClusterwideNetworkPolicySpec {
+    endpointSelector?: LabelSelector;
+    nodeSelector?: LabelSelector;
+    ingress?: IngressRule[];
+    egress?: EgressRule[];
+    description?: string;
+}
+/**
+ * CiliumClusterwideNetworkPolicy status interface
+ */
+export interface CiliumClusterwideNetworkPolicyStatus {
+    conditions?: Condition[];
+    state?: string;
+    message?: string;
+    nodes?: {
+        [nodeName: string]: {
+            ok?: boolean;
+            error?: string;
+            lastUpdated?: string;
+        };
+    };
+}
+/**
+ * Generic Cilium resource status
+ */
+export interface CiliumResourceStatus {
+    conditions?: Condition[];
+    state?: string;
+    message?: string;
+}
+/**
+ * Kubernetes condition
+ */
+export interface Condition {
+    type: string;
+    status: 'True' | 'False' | 'Unknown';
+    lastTransitionTime?: string;
+    reason?: string;
+    message?: string;
+}
+/**
+ * BGP session status
+ */
+export interface BGPSessionStatus {
+    localASN: number;
+    peerASN: number;
+    peerAddress: string;
+    sessionState: 'Idle' | 'Connect' | 'Active' | 'OpenSent' | 'OpenConfirm' | 'Established';
+    uptimeNanoseconds?: number;
+    keepAliveTimeSeconds?: number;
+    opensSent?: number;
+    opensReceived?: number;
+    notificationsSent?: number;
+    notificationsReceived?: number;
+    updatesSent?: number;
+    updatesReceived?: number;
+}
+/**
+ * Readiness evaluation result
+ */
+export interface ReadinessResult {
+    ready: boolean;
+    message: string;
+    details?: Record<string, any>;
+    lastTransition?: string | undefined;
+    reason?: string;
+}
+/**
+ * Configuration interface for Cilium HelmRepository
+ */
+export interface CiliumHelmRepositoryConfig {
+    name: string;
+    namespace?: string;
+    interval?: string;
+    timeout?: string;
+    labels?: Record<string, string>;
+    annotations?: Record<string, string>;
+    secretRef?: {
+        name: string;
+    };
+    id?: string;
+}
+/**
+ * Configuration interface for Cilium HelmRelease
+ */
+export interface CiliumHelmReleaseConfig {
+    name: string;
+    namespace?: string;
+    version?: string;
+    repositoryName: string;
+    repositoryNamespace: string;
+    interval?: string;
+    timeout?: string;
+    installTimeout?: string;
+    upgradeTimeout?: string;
+    replace?: boolean;
+    createNamespace?: boolean;
+    cleanupOnFail?: boolean;
+    values?: Record<string, any>;
+    labels?: Record<string, string>;
+    annotations?: Record<string, string>;
+    id?: string;
+}
+/**
+ * Cilium Helm values interface
+ */
+export interface CiliumHelmValues {
+    cluster: {
+        name: string;
+        id: number;
+    };
+    ipam?: {
+        mode?: 'kubernetes' | 'cluster-pool' | 'azure' | 'aws-eni' | 'crd';
+        operator?: {
+            clusterPoolIPv4PodCIDRList?: string[];
+            clusterPoolIPv6PodCIDRList?: string[];
+        };
+    };
+    kubeProxyReplacement?: boolean | 'partial';
+    routingMode?: 'tunnel' | 'native';
+    tunnelProtocol?: 'vxlan' | 'geneve';
+    autoDirectNodeRoutes?: boolean;
+    endpointRoutes?: {
+        enabled?: boolean;
+    };
+    hostServices?: {
+        enabled?: boolean;
+        protocols?: ('tcp' | 'udp')[];
+    };
+    nodePort?: {
+        enabled?: boolean;
+        range?: string;
+    };
+    externalIPs?: {
+        enabled?: boolean;
+    };
+    hostPort?: {
+        enabled?: boolean;
+    };
+    loadBalancer?: {
+        algorithm?: 'random' | 'round_robin' | 'maglev';
+        mode?: 'snat' | 'dsr' | 'hybrid';
+        acceleration?: 'disabled' | 'native' | 'best-effort';
+    };
+    encryption?: {
+        enabled?: boolean;
+        type?: 'wireguard' | 'ipsec';
+        nodeEncryption?: boolean;
+        wireguard?: {
+            userspaceFallback?: boolean;
+            persistentKeepalive?: number;
+        };
+        ipsec?: {
+            interface?: string;
+            mountPath?: string;
+            keyFile?: string;
+        };
+    };
+    authentication?: {
+        enabled?: boolean;
+        mutual?: {
+            spire?: {
+                enabled?: boolean;
+                install?: boolean;
+            };
+        };
+    };
+    policyEnforcement?: 'default' | 'always' | 'never';
+    policyAuditMode?: boolean;
+    bgp?: {
+        enabled?: boolean;
+        announce?: {
+            loadbalancerIP?: boolean;
+            podCIDR?: boolean;
+        };
+    };
+    gatewayAPI?: {
+        enabled?: boolean;
+        secretsNamespace?: {
+            create?: boolean;
+            name?: string;
+        };
+    };
+    hubble?: {
+        enabled?: boolean;
+        metrics?: {
+            enabled?: string[];
+            enableOpenMetrics?: boolean;
+            port?: number;
+        };
+        relay?: {
+            enabled?: boolean;
+            replicas?: number;
+        };
+        ui?: {
+            enabled?: boolean;
+            replicas?: number;
+            ingress?: {
+                enabled?: boolean;
+                hosts?: string[];
+            };
+        };
+    };
+    prometheus?: {
+        enabled?: boolean;
+        port?: number;
+        serviceMonitor?: {
+            enabled?: boolean;
+        };
+    };
+    operator?: {
+        replicas?: number;
+        resources?: {
+            limits?: {
+                cpu?: string;
+                memory?: string;
+            };
+            requests?: {
+                cpu?: string;
+                memory?: string;
+            };
+        };
+    };
+    agent?: {
+        resources?: {
+            limits?: {
+                cpu?: string;
+                memory?: string;
+            };
+            requests?: {
+                cpu?: string;
+                memory?: string;
+            };
+        };
+    };
+    bpf?: {
+        preallocateMaps?: boolean;
+        mapDynamicSizeRatio?: number;
+    };
+    k8s?: {
+        requireIPv4PodCIDR?: boolean;
+        requireIPv6PodCIDR?: boolean;
+    };
+    cni?: {
+        binPath?: string;
+        confPath?: string;
+    };
+    [key: string]: any;
+}
+/**
+ * Cilium configuration validation error
+ */
+export declare class CiliumConfigurationError extends TypeKroError {
+    readonly configPath: string;
+    readonly validationErrors: string[];
+    constructor(message: string, configPath: string, validationErrors: string[]);
+}
+/**
+ * Cilium resource validation error
+ */
+export declare class CiliumResourceValidationError extends TypeKroError {
+    readonly resourceType: string;
+    readonly resourceName: string;
+    constructor(message: string, resourceType: string, resourceName: string);
+}
+/**
+ * Cilium deployment error
+ */
+export declare class CiliumDeploymentError extends TypeKroError {
+    readonly phase: string;
+    readonly componentErrors: string[];
+    constructor(message: string, phase: string, componentErrors: string[]);
+}
+/**
+ * Cilium readiness evaluation error
+ */
+export declare class CiliumReadinessError extends TypeKroError {
+    readonly component: string;
+    readonly expectedState: string;
+    readonly actualState: string;
+    constructor(message: string, component: string, expectedState: string, actualState: string);
+}
+//# sourceMappingURL=types.d.ts.map