@microsoft/terraform-cdk-constructs 1.3.1 → 1.4.0

package/lib/azure-virtualnetworkmanager/lib/utils/cidr-validator.d.ts

@@ -0,0 +1,225 @@
+/**
+ * CIDR Validator Utility
+ *
+ * Provides comprehensive validation and parsing utilities for IPv4 CIDR notation.
+ * Used by IPAM constructs to ensure proper network address space management.
+ */
+/**
+ * Result of CIDR validation operations
+ */
+export interface CidrValidationResult {
+    /** Whether the validation passed */
+    readonly valid: boolean;
+    /** List of validation errors */
+    readonly errors: string[];
+    /** List of validation warnings */
+    readonly warnings: string[];
+}
+/**
+ * Parsed CIDR information
+ */
+export interface ParsedCidr {
+    /** Original CIDR notation (e.g., "10.0.0.0/8") */
+    readonly cidr: string;
+    /** Network address (e.g., "10.0.0.0") */
+    readonly network: string;
+    /** Prefix length (e.g., 8) */
+    readonly prefix: number;
+    /** First usable IP address */
+    readonly firstIp: string;
+    /** Last usable IP address */
+    readonly lastIp: string;
+    /** Total number of addresses in the range */
+    readonly totalAddresses: number;
+    /** Network mask (e.g., "255.0.0.0") */
+    readonly netmask: string;
+}
+/**
+ * Validates if a string is a valid CIDR notation
+ *
+ * @param cidr - CIDR string (e.g., "10.0.0.0/16")
+ * @returns boolean - true if valid CIDR format
+ *
+ * @example
+ * const valid = isValidCidr("10.0.0.0/16");
+ * console.log(valid); // true
+ */
+export declare function isValidCidr(cidr: string): boolean;
+/**
+ * Validates if CIDR is within allowed private ranges (RFC 1918)
+ *
+ * @param cidr - CIDR string
+ * @returns boolean - true if within private IP range
+ *
+ * @example
+ * const isPrivate = isPrivateRange("10.0.0.0/16");
+ * console.log(isPrivate); // true
+ */
+export declare function isPrivateRange(cidr: string): boolean;
+/**
+ * Checks if two CIDR blocks overlap
+ *
+ * @param cidr1 - First CIDR
+ * @param cidr2 - Second CIDR
+ * @returns boolean - true if CIDRs overlap
+ *
+ * @example
+ * const overlap = cidrsOverlap("10.0.0.0/8", "10.1.0.0/16");
+ * console.log(overlap); // true
+ */
+export declare function cidrsOverlap(cidr1: string, cidr2: string): boolean;
+/**
+ * Validates if child CIDR is contained within parent CIDR
+ *
+ * @param childCidr - Child CIDR block
+ * @param parentCidr - Parent CIDR block
+ * @returns boolean - true if child is subnet of parent
+ *
+ * @example
+ * const isSubnet = isSubnet("10.1.0.0/16", "10.0.0.0/8");
+ * console.log(isSubnet); // true
+ */
+export declare function isSubnet(childCidr: string, parentCidr: string): boolean;
+/**
+ * Calculates number of IP addresses in a CIDR block
+ *
+ * @param cidr - CIDR string
+ * @returns number - Total IP addresses in the block
+ *
+ * @example
+ * const count = calculateAddressCount("10.0.0.0/24");
+ * console.log(count); // 256
+ */
+export declare function calculateAddressCount(cidr: string): number;
+/**
+ * Validates prefix length is within allowed range
+ *
+ * @param cidr - CIDR string
+ * @param minPrefix - Minimum allowed prefix (e.g., 8)
+ * @param maxPrefix - Maximum allowed prefix (e.g., 29)
+ * @returns boolean - true if prefix length is within range
+ *
+ * @example
+ * const valid = isValidPrefixLength("10.0.0.0/24", 8, 29);
+ * console.log(valid); // true
+ */
+export declare function isValidPrefixLength(cidr: string, minPrefix: number, maxPrefix: number): boolean;
+/**
+ * Validate CIDR format and structure
+ *
+ * @param cidr - CIDR notation string (e.g., "10.0.0.0/8")
+ * @returns Validation result with errors and warnings
+ *
+ * @example
+ * const result = validateCidr("10.0.0.0/8");
+ * if (!result.valid) {
+ *   console.error("Invalid CIDR:", result.errors);
+ * }
+ */
+export declare function validateCidr(cidr: string): CidrValidationResult;
+/**
+ * Parse CIDR into structured information
+ *
+ * @param cidr - CIDR notation string
+ * @returns Parsed CIDR information
+ * @throws Error if CIDR format is invalid
+ *
+ * @example
+ * const parsed = parseCidr("10.0.0.0/8");
+ * console.log(`Network: ${parsed.network}, Prefix: ${parsed.prefix}`);
+ * console.log(`Range: ${parsed.firstIp} - ${parsed.lastIp}`);
+ * console.log(`Total addresses: ${parsed.totalAddresses}`);
+ */
+export declare function parseCidr(cidr: string): ParsedCidr;
+/**
+ * Check if two CIDRs overlap
+ *
+ * @param cidr1 - First CIDR block
+ * @param cidr2 - Second CIDR block
+ * @returns True if the CIDRs overlap
+ *
+ * @example
+ * const overlaps = checkOverlap("10.0.0.0/16", "10.0.1.0/24");
+ * console.log(overlaps); // true
+ */
+export declare function checkOverlap(cidr1: string, cidr2: string): boolean;
+/**
+ * Validate that multiple CIDRs don't overlap
+ *
+ * @param cidrs - Array of CIDR blocks to check
+ * @returns Validation result with details of any overlaps
+ *
+ * @example
+ * const result = validateNoOverlaps([
+ *   "10.0.0.0/16",
+ *   "10.1.0.0/16",
+ *   "10.0.1.0/24"
+ * ]);
+ * if (!result.valid) {
+ *   console.error("Overlapping CIDRs:", result.errors);
+ * }
+ */
+export declare function validateNoOverlaps(cidrs: string[]): CidrValidationResult;
+/**
+ * Check if a child CIDR is contained within a parent CIDR
+ *
+ * @param parentCidr - Parent CIDR block
+ * @param childCidr - Child CIDR block to check
+ * @returns True if child is fully contained in parent
+ *
+ * @example
+ * const contained = isContained("10.0.0.0/16", "10.0.1.0/24");
+ * console.log(contained); // true
+ */
+export declare function isContained(parentCidr: string, childCidr: string): boolean;
+/**
+ * Validate that multiple child CIDRs are all contained within a parent CIDR
+ *
+ * @param parentCidr - Parent CIDR block
+ * @param childCidrs - Array of child CIDR blocks
+ * @returns Validation result with details of any containment violations
+ *
+ * @example
+ * const result = validateContainment("10.0.0.0/16", [
+ *   "10.0.1.0/24",
+ *   "10.0.2.0/24"
+ * ]);
+ * if (!result.valid) {
+ *   console.error("Containment violations:", result.errors);
+ * }
+ */
+export declare function validateContainment(parentCidr: string, childCidrs: string[]): CidrValidationResult;
+/**
+ * Convert an IP address string to a 32-bit number
+ *
+ * @param ip - IP address string (e.g., "10.0.0.1")
+ * @returns 32-bit number representation
+ *
+ * @example
+ * const num = ipToNumber("10.0.0.1");
+ * console.log(num); // 167772161
+ */
+export declare function ipToNumber(ip: string): number;
+/**
+ * Convert a 32-bit number to an IP address string
+ *
+ * @param num - 32-bit number representation
+ * @returns IP address string
+ *
+ * @example
+ * const ip = numberToIp(167772161);
+ * console.log(ip); // "10.0.0.1"
+ */
+export declare function numberToIp(num: number): string;
+/**
+ * Convert a prefix length to a netmask number
+ *
+ * @param prefix - Prefix length (0-32)
+ * @returns 32-bit netmask number
+ *
+ * @example
+ * const mask = prefixToMask(24);
+ * const maskIp = numberToIp(mask);
+ * console.log(maskIp); // "255.255.255.0"
+ */
+export declare function prefixToMask(prefix: number): number;

package/lib/azure-virtualnetworkmanager/lib/utils/cidr-validator.js

@@ -0,0 +1,389 @@
+"use strict";
+/**
+ * CIDR Validator Utility
+ *
+ * Provides comprehensive validation and parsing utilities for IPv4 CIDR notation.
+ * Used by IPAM constructs to ensure proper network address space management.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidCidr = isValidCidr;
+exports.isPrivateRange = isPrivateRange;
+exports.cidrsOverlap = cidrsOverlap;
+exports.isSubnet = isSubnet;
+exports.calculateAddressCount = calculateAddressCount;
+exports.isValidPrefixLength = isValidPrefixLength;
+exports.validateCidr = validateCidr;
+exports.parseCidr = parseCidr;
+exports.checkOverlap = checkOverlap;
+exports.validateNoOverlaps = validateNoOverlaps;
+exports.isContained = isContained;
+exports.validateContainment = validateContainment;
+exports.ipToNumber = ipToNumber;
+exports.numberToIp = numberToIp;
+exports.prefixToMask = prefixToMask;
+const IPV4_REGEX = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\/(\d{1,2})$/;
+// RFC 1918 private IP ranges
+const PRIVATE_RANGES = [
+    { start: "10.0.0.0", end: "10.255.255.255", cidr: "10.0.0.0/8" },
+    { start: "172.16.0.0", end: "172.31.255.255", cidr: "172.16.0.0/12" },
+    { start: "192.168.0.0", end: "192.168.255.255", cidr: "192.168.0.0/16" },
+];
+/**
+ * Validates if a string is a valid CIDR notation
+ *
+ * @param cidr - CIDR string (e.g., "10.0.0.0/16")
+ * @returns boolean - true if valid CIDR format
+ *
+ * @example
+ * const valid = isValidCidr("10.0.0.0/16");
+ * console.log(valid); // true
+ */
+function isValidCidr(cidr) {
+    const result = validateCidr(cidr);
+    return result.valid;
+}
+/**
+ * Validates if CIDR is within allowed private ranges (RFC 1918)
+ *
+ * @param cidr - CIDR string
+ * @returns boolean - true if within private IP range
+ *
+ * @example
+ * const isPrivate = isPrivateRange("10.0.0.0/16");
+ * console.log(isPrivate); // true
+ */
+function isPrivateRange(cidr) {
+    if (!isValidCidr(cidr)) {
+        return false;
+    }
+    const parsed = parseCidr(cidr);
+    const startNum = ipToNumber(parsed.firstIp);
+    const endNum = ipToNumber(parsed.lastIp);
+    // Check if the entire CIDR range falls within any private range
+    return PRIVATE_RANGES.some((range) => {
+        const rangeStart = ipToNumber(range.start);
+        const rangeEnd = ipToNumber(range.end);
+        return startNum >= rangeStart && endNum <= rangeEnd;
+    });
+}
+/**
+ * Checks if two CIDR blocks overlap
+ *
+ * @param cidr1 - First CIDR
+ * @param cidr2 - Second CIDR
+ * @returns boolean - true if CIDRs overlap
+ *
+ * @example
+ * const overlap = cidrsOverlap("10.0.0.0/8", "10.1.0.0/16");
+ * console.log(overlap); // true
+ */
+function cidrsOverlap(cidr1, cidr2) {
+    return checkOverlap(cidr1, cidr2);
+}
+/**
+ * Validates if child CIDR is contained within parent CIDR
+ *
+ * @param childCidr - Child CIDR block
+ * @param parentCidr - Parent CIDR block
+ * @returns boolean - true if child is subnet of parent
+ *
+ * @example
+ * const isSubnet = isSubnet("10.1.0.0/16", "10.0.0.0/8");
+ * console.log(isSubnet); // true
+ */
+function isSubnet(childCidr, parentCidr) {
+    return isContained(parentCidr, childCidr);
+}
+/**
+ * Calculates number of IP addresses in a CIDR block
+ *
+ * @param cidr - CIDR string
+ * @returns number - Total IP addresses in the block
+ *
+ * @example
+ * const count = calculateAddressCount("10.0.0.0/24");
+ * console.log(count); // 256
+ */
+function calculateAddressCount(cidr) {
+    const parsed = parseCidr(cidr);
+    return parsed.totalAddresses;
+}
+/**
+ * Validates prefix length is within allowed range
+ *
+ * @param cidr - CIDR string
+ * @param minPrefix - Minimum allowed prefix (e.g., 8)
+ * @param maxPrefix - Maximum allowed prefix (e.g., 29)
+ * @returns boolean - true if prefix length is within range
+ *
+ * @example
+ * const valid = isValidPrefixLength("10.0.0.0/24", 8, 29);
+ * console.log(valid); // true
+ */
+function isValidPrefixLength(cidr, minPrefix, maxPrefix) {
+    if (!isValidCidr(cidr)) {
+        return false;
+    }
+    const parsed = parseCidr(cidr);
+    return parsed.prefix >= minPrefix && parsed.prefix <= maxPrefix;
+}
+/**
+ * Validate CIDR format and structure
+ *
+ * @param cidr - CIDR notation string (e.g., "10.0.0.0/8")
+ * @returns Validation result with errors and warnings
+ *
+ * @example
+ * const result = validateCidr("10.0.0.0/8");
+ * if (!result.valid) {
+ *   console.error("Invalid CIDR:", result.errors);
+ * }
+ */
+function validateCidr(cidr) {
+    const errors = [];
+    const warnings = [];
+    if (!cidr || typeof cidr !== "string") {
+        errors.push("CIDR must be a non-empty string");
+        return { valid: false, errors, warnings };
+    }
+    const match = cidr.match(IPV4_REGEX);
+    if (!match) {
+        errors.push(`Invalid CIDR format: ${cidr}. Expected format: x.x.x.x/y`);
+        return { valid: false, errors, warnings };
+    }
+    const [, oct1, oct2, oct3, oct4, prefix] = match;
+    const octets = [oct1, oct2, oct3, oct4].map(Number);
+    const prefixLength = Number(prefix);
+    // Validate octets (0-255)
+    for (let i = 0; i < octets.length; i++) {
+        if (octets[i] < 0 || octets[i] > 255) {
+            errors.push(`Invalid octet value: ${octets[i]}. Must be between 0 and 255`);
+        }
+    }
+    // Validate prefix length (0-32)
+    if (prefixLength < 0 || prefixLength > 32) {
+        errors.push(`Invalid prefix length: ${prefixLength}. Must be between 0 and 32`);
+    }
+    if (errors.length > 0) {
+        return { valid: false, errors, warnings };
+    }
+    // Verify network address alignment
+    const ipNum = ipToNumber(octets.join("."));
+    const mask = prefixToMask(prefixLength);
+    const networkNum = ipNum & mask;
+    if (ipNum !== networkNum) {
+        const correctNetwork = numberToIp(networkNum);
+        warnings.push(`IP address ${octets.join(".")} is not aligned to network boundary. ` +
+            `Network address should be ${correctNetwork}/${prefixLength}`);
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}
+/**
+ * Parse CIDR into structured information
+ *
+ * @param cidr - CIDR notation string
+ * @returns Parsed CIDR information
+ * @throws Error if CIDR format is invalid
+ *
+ * @example
+ * const parsed = parseCidr("10.0.0.0/8");
+ * console.log(`Network: ${parsed.network}, Prefix: ${parsed.prefix}`);
+ * console.log(`Range: ${parsed.firstIp} - ${parsed.lastIp}`);
+ * console.log(`Total addresses: ${parsed.totalAddresses}`);
+ */
+function parseCidr(cidr) {
+    const validation = validateCidr(cidr);
+    if (!validation.valid) {
+        throw new Error(`Invalid CIDR: ${validation.errors.join(", ")}`);
+    }
+    const match = cidr.match(IPV4_REGEX);
+    const [, oct1, oct2, oct3, oct4, prefix] = match;
+    const ipAddress = `${oct1}.${oct2}.${oct3}.${oct4}`;
+    const prefixLength = Number(prefix);
+    const ipNum = ipToNumber(ipAddress);
+    const mask = prefixToMask(prefixLength);
+    const networkNum = ipNum & mask;
+    const broadcastNum = networkNum | (~mask >>> 0);
+    const totalAddresses = Math.pow(2, 32 - prefixLength);
+    const firstIpNum = networkNum;
+    const lastIpNum = broadcastNum;
+    return {
+        cidr,
+        network: numberToIp(networkNum),
+        prefix: prefixLength,
+        firstIp: numberToIp(firstIpNum),
+        lastIp: numberToIp(lastIpNum),
+        totalAddresses,
+        netmask: numberToIp(mask),
+    };
+}
+/**
+ * Check if two CIDRs overlap
+ *
+ * @param cidr1 - First CIDR block
+ * @param cidr2 - Second CIDR block
+ * @returns True if the CIDRs overlap
+ *
+ * @example
+ * const overlaps = checkOverlap("10.0.0.0/16", "10.0.1.0/24");
+ * console.log(overlaps); // true
+ */
+function checkOverlap(cidr1, cidr2) {
+    const parsed1 = parseCidr(cidr1);
+    const parsed2 = parseCidr(cidr2);
+    const start1 = ipToNumber(parsed1.firstIp);
+    const end1 = ipToNumber(parsed1.lastIp);
+    const start2 = ipToNumber(parsed2.firstIp);
+    const end2 = ipToNumber(parsed2.lastIp);
+    // Check if ranges overlap
+    return !(end1 < start2 || end2 < start1);
+}
+/**
+ * Validate that multiple CIDRs don't overlap
+ *
+ * @param cidrs - Array of CIDR blocks to check
+ * @returns Validation result with details of any overlaps
+ *
+ * @example
+ * const result = validateNoOverlaps([
+ *   "10.0.0.0/16",
+ *   "10.1.0.0/16",
+ *   "10.0.1.0/24"
+ * ]);
+ * if (!result.valid) {
+ *   console.error("Overlapping CIDRs:", result.errors);
+ * }
+ */
+function validateNoOverlaps(cidrs) {
+    const errors = [];
+    const warnings = [];
+    // First validate each CIDR individually
+    for (const cidr of cidrs) {
+        const validation = validateCidr(cidr);
+        if (!validation.valid) {
+            errors.push(`Invalid CIDR ${cidr}: ${validation.errors.join(", ")}`);
+        }
+    }
+    if (errors.length > 0) {
+        return { valid: false, errors, warnings };
+    }
+    // Check for overlaps
+    for (let i = 0; i < cidrs.length; i++) {
+        for (let j = i + 1; j < cidrs.length; j++) {
+            if (checkOverlap(cidrs[i], cidrs[j])) {
+                errors.push(`CIDRs overlap: ${cidrs[i]} and ${cidrs[j]}`);
+            }
+        }
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}
+/**
+ * Check if a child CIDR is contained within a parent CIDR
+ *
+ * @param parentCidr - Parent CIDR block
+ * @param childCidr - Child CIDR block to check
+ * @returns True if child is fully contained in parent
+ *
+ * @example
+ * const contained = isContained("10.0.0.0/16", "10.0.1.0/24");
+ * console.log(contained); // true
+ */
+function isContained(parentCidr, childCidr) {
+    const parent = parseCidr(parentCidr);
+    const child = parseCidr(childCidr);
+    const parentStart = ipToNumber(parent.firstIp);
+    const parentEnd = ipToNumber(parent.lastIp);
+    const childStart = ipToNumber(child.firstIp);
+    const childEnd = ipToNumber(child.lastIp);
+    // Child must be fully within parent range
+    return childStart >= parentStart && childEnd <= parentEnd;
+}
+/**
+ * Validate that multiple child CIDRs are all contained within a parent CIDR
+ *
+ * @param parentCidr - Parent CIDR block
+ * @param childCidrs - Array of child CIDR blocks
+ * @returns Validation result with details of any containment violations
+ *
+ * @example
+ * const result = validateContainment("10.0.0.0/16", [
+ *   "10.0.1.0/24",
+ *   "10.0.2.0/24"
+ * ]);
+ * if (!result.valid) {
+ *   console.error("Containment violations:", result.errors);
+ * }
+ */
+function validateContainment(parentCidr, childCidrs) {
+    const errors = [];
+    const warnings = [];
+    // Validate parent CIDR
+    const parentValidation = validateCidr(parentCidr);
+    if (!parentValidation.valid) {
+        errors.push(`Invalid parent CIDR ${parentCidr}: ${parentValidation.errors.join(", ")}`);
+        return { valid: false, errors, warnings };
+    }
+    // Validate each child CIDR
+    for (const childCidr of childCidrs) {
+        const childValidation = validateCidr(childCidr);
+        if (!childValidation.valid) {
+            errors.push(`Invalid child CIDR ${childCidr}: ${childValidation.errors.join(", ")}`);
+            continue;
+        }
+        // Check containment
+        if (!isContained(parentCidr, childCidr)) {
+            errors.push(`Child CIDR ${childCidr} is not contained within parent CIDR ${parentCidr}`);
+        }
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}
+/**
+ * Convert an IP address string to a 32-bit number
+ *
+ * @param ip - IP address string (e.g., "10.0.0.1")
+ * @returns 32-bit number representation
+ *
+ * @example
+ * const num = ipToNumber("10.0.0.1");
+ * console.log(num); // 167772161
+ */
+function ipToNumber(ip) {
+    const octets = ip.split(".").map(Number);
+    return (((octets[0] << 24) >>> 0) +
+        ((octets[1] << 16) >>> 0) +
+        ((octets[2] << 8) >>> 0) +
+        octets[3]);
+}
+/**
+ * Convert a 32-bit number to an IP address string
+ *
+ * @param num - 32-bit number representation
+ * @returns IP address string
+ *
+ * @example
+ * const ip = numberToIp(167772161);
+ * console.log(ip); // "10.0.0.1"
+ */
+function numberToIp(num) {
+    return [
+        (num >>> 24) & 0xff,
+        (num >>> 16) & 0xff,
+        (num >>> 8) & 0xff,
+        num & 0xff,
+    ].join(".");
+}
+/**
+ * Convert a prefix length to a netmask number
+ *
+ * @param prefix - Prefix length (0-32)
+ * @returns 32-bit netmask number
+ *
+ * @example
+ * const mask = prefixToMask(24);
+ * const maskIp = numberToIp(mask);
+ * console.log(maskIp); // "255.255.255.0"
+ */
+function prefixToMask(prefix) {
+    return prefix === 0 ? 0 : (0xffffffff << (32 - prefix)) >>> 0;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cidr-validator.js","sourceRoot":"","sources":["../../../../src/azure-virtualnetworkmanager/lib/utils/cidr-validator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * CIDR Validator Utility\n *\n * Provides comprehensive validation and parsing utilities for IPv4 CIDR notation.\n * Used by IPAM constructs to ensure proper network address space management.\n */\n\n/* eslint-disable no-bitwise */\n\n/**\n * Result of CIDR validation operations\n */\nexport interface CidrValidationResult {\n  /** Whether the validation passed */\n  readonly valid: boolean;\n  /** List of validation errors */\n  readonly errors: string[];\n  /** List of validation warnings */\n  readonly warnings: string[];\n}\n\n/**\n * Parsed CIDR information\n */\nexport interface ParsedCidr {\n  /** Original CIDR notation (e.g., \"10.0.0.0/8\") */\n  readonly cidr: string;\n  /** Network address (e.g., \"10.0.0.0\") */\n  readonly network: string;\n  /** Prefix length (e.g., 8) */\n  readonly prefix: number;\n  /** First usable IP address */\n  readonly firstIp: string;\n  /** Last usable IP address */\n  readonly lastIp: string;\n  /** Total number of addresses in the range */\n  readonly totalAddresses: number;\n  /** Network mask (e.g., \"255.0.0.0\") */\n  readonly netmask: string;\n}\n\nconst IPV4_REGEX = /^(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\/(\\d{1,2})$/;\n\n// RFC 1918 private IP ranges\nconst PRIVATE_RANGES = [\n  { start: \"10.0.0.0\", end: \"10.255.255.255\", cidr: \"10.0.0.0/8\" },\n  { start: \"172.16.0.0\", end: \"172.31.255.255\", cidr: \"172.16.0.0/12\" },\n  { start: \"192.168.0.0\", end: \"192.168.255.255\", cidr: \"192.168.0.0/16\" },\n];\n\n/**\n * Validates if a string is a valid CIDR notation\n *\n * @param cidr - CIDR string (e.g., \"10.0.0.0/16\")\n * @returns boolean - true if valid CIDR format\n *\n * @example\n * const valid = isValidCidr(\"10.0.0.0/16\");\n * console.log(valid); // true\n */\nexport function isValidCidr(cidr: string): boolean {\n  const result = validateCidr(cidr);\n  return result.valid;\n}\n\n/**\n * Validates if CIDR is within allowed private ranges (RFC 1918)\n *\n * @param cidr - CIDR string\n * @returns boolean - true if within private IP range\n *\n * @example\n * const isPrivate = isPrivateRange(\"10.0.0.0/16\");\n * console.log(isPrivate); // true\n */\nexport function isPrivateRange(cidr: string): boolean {\n  if (!isValidCidr(cidr)) {\n    return false;\n  }\n\n  const parsed = parseCidr(cidr);\n  const startNum = ipToNumber(parsed.firstIp);\n  const endNum = ipToNumber(parsed.lastIp);\n\n  // Check if the entire CIDR range falls within any private range\n  return PRIVATE_RANGES.some((range) => {\n    const rangeStart = ipToNumber(range.start);\n    const rangeEnd = ipToNumber(range.end);\n    return startNum >= rangeStart && endNum <= rangeEnd;\n  });\n}\n\n/**\n * Checks if two CIDR blocks overlap\n *\n * @param cidr1 - First CIDR\n * @param cidr2 - Second CIDR\n * @returns boolean - true if CIDRs overlap\n *\n * @example\n * const overlap = cidrsOverlap(\"10.0.0.0/8\", \"10.1.0.0/16\");\n * console.log(overlap); // true\n */\nexport function cidrsOverlap(cidr1: string, cidr2: string): boolean {\n  return checkOverlap(cidr1, cidr2);\n}\n\n/**\n * Validates if child CIDR is contained within parent CIDR\n *\n * @param childCidr - Child CIDR block\n * @param parentCidr - Parent CIDR block\n * @returns boolean - true if child is subnet of parent\n *\n * @example\n * const isSubnet = isSubnet(\"10.1.0.0/16\", \"10.0.0.0/8\");\n * console.log(isSubnet); // true\n */\nexport function isSubnet(childCidr: string, parentCidr: string): boolean {\n  return isContained(parentCidr, childCidr);\n}\n\n/**\n * Calculates number of IP addresses in a CIDR block\n *\n * @param cidr - CIDR string\n * @returns number - Total IP addresses in the block\n *\n * @example\n * const count = calculateAddressCount(\"10.0.0.0/24\");\n * console.log(count); // 256\n */\nexport function calculateAddressCount(cidr: string): number {\n  const parsed = parseCidr(cidr);\n  return parsed.totalAddresses;\n}\n\n/**\n * Validates prefix length is within allowed range\n *\n * @param cidr - CIDR string\n * @param minPrefix - Minimum allowed prefix (e.g., 8)\n * @param maxPrefix - Maximum allowed prefix (e.g., 29)\n * @returns boolean - true if prefix length is within range\n *\n * @example\n * const valid = isValidPrefixLength(\"10.0.0.0/24\", 8, 29);\n * console.log(valid); // true\n */\nexport function isValidPrefixLength(\n  cidr: string,\n  minPrefix: number,\n  maxPrefix: number,\n): boolean {\n  if (!isValidCidr(cidr)) {\n    return false;\n  }\n\n  const parsed = parseCidr(cidr);\n  return parsed.prefix >= minPrefix && parsed.prefix <= maxPrefix;\n}\n\n/**\n * Validate CIDR format and structure\n *\n * @param cidr - CIDR notation string (e.g., \"10.0.0.0/8\")\n * @returns Validation result with errors and warnings\n *\n * @example\n * const result = validateCidr(\"10.0.0.0/8\");\n * if (!result.valid) {\n *   console.error(\"Invalid CIDR:\", result.errors);\n * }\n */\nexport function validateCidr(cidr: string): CidrValidationResult {\n  const errors: string[] = [];\n  const warnings: string[] = [];\n\n  if (!cidr || typeof cidr !== \"string\") {\n    errors.push(\"CIDR must be a non-empty string\");\n    return { valid: false, errors, warnings };\n  }\n\n  const match = cidr.match(IPV4_REGEX);\n  if (!match) {\n    errors.push(`Invalid CIDR format: ${cidr}. Expected format: x.x.x.x/y`);\n    return { valid: false, errors, warnings };\n  }\n\n  const [, oct1, oct2, oct3, oct4, prefix] = match;\n  const octets = [oct1, oct2, oct3, oct4].map(Number);\n  const prefixLength = Number(prefix);\n\n  // Validate octets (0-255)\n  for (let i = 0; i < octets.length; i++) {\n    if (octets[i] < 0 || octets[i] > 255) {\n      errors.push(\n        `Invalid octet value: ${octets[i]}. Must be between 0 and 255`,\n      );\n    }\n  }\n\n  // Validate prefix length (0-32)\n  if (prefixLength < 0 || prefixLength > 32) {\n    errors.push(\n      `Invalid prefix length: ${prefixLength}. Must be between 0 and 32`,\n    );\n  }\n\n  if (errors.length > 0) {\n    return { valid: false, errors, warnings };\n  }\n\n  // Verify network address alignment\n  const ipNum = ipToNumber(octets.join(\".\"));\n  const mask = prefixToMask(prefixLength);\n  const networkNum = ipNum & mask;\n\n  if (ipNum !== networkNum) {\n    const correctNetwork = numberToIp(networkNum);\n    warnings.push(\n      `IP address ${octets.join(\".\")} is not aligned to network boundary. ` +\n        `Network address should be ${correctNetwork}/${prefixLength}`,\n    );\n  }\n\n  return { valid: errors.length === 0, errors, warnings };\n}\n\n/**\n * Parse CIDR into structured information\n *\n * @param cidr - CIDR notation string\n * @returns Parsed CIDR information\n * @throws Error if CIDR format is invalid\n *\n * @example\n * const parsed = parseCidr(\"10.0.0.0/8\");\n * console.log(`Network: ${parsed.network}, Prefix: ${parsed.prefix}`);\n * console.log(`Range: ${parsed.firstIp} - ${parsed.lastIp}`);\n * console.log(`Total addresses: ${parsed.totalAddresses}`);\n */\nexport function parseCidr(cidr: string): ParsedCidr {\n  const validation = validateCidr(cidr);\n  if (!validation.valid) {\n    throw new Error(`Invalid CIDR: ${validation.errors.join(\", \")}`);\n  }\n\n  const match = cidr.match(IPV4_REGEX)!;\n  const [, oct1, oct2, oct3, oct4, prefix] = match;\n  const ipAddress = `${oct1}.${oct2}.${oct3}.${oct4}`;\n  const prefixLength = Number(prefix);\n\n  const ipNum = ipToNumber(ipAddress);\n  const mask = prefixToMask(prefixLength);\n  const networkNum = ipNum & mask;\n  const broadcastNum = networkNum | (~mask >>> 0);\n\n  const totalAddresses = Math.pow(2, 32 - prefixLength);\n  const firstIpNum = networkNum;\n  const lastIpNum = broadcastNum;\n\n  return {\n    cidr,\n    network: numberToIp(networkNum),\n    prefix: prefixLength,\n    firstIp: numberToIp(firstIpNum),\n    lastIp: numberToIp(lastIpNum),\n    totalAddresses,\n    netmask: numberToIp(mask),\n  };\n}\n\n/**\n * Check if two CIDRs overlap\n *\n * @param cidr1 - First CIDR block\n * @param cidr2 - Second CIDR block\n * @returns True if the CIDRs overlap\n *\n * @example\n * const overlaps = checkOverlap(\"10.0.0.0/16\", \"10.0.1.0/24\");\n * console.log(overlaps); // true\n */\nexport function checkOverlap(cidr1: string, cidr2: string): boolean {\n  const parsed1 = parseCidr(cidr1);\n  const parsed2 = parseCidr(cidr2);\n\n  const start1 = ipToNumber(parsed1.firstIp);\n  const end1 = ipToNumber(parsed1.lastIp);\n  const start2 = ipToNumber(parsed2.firstIp);\n  const end2 = ipToNumber(parsed2.lastIp);\n\n  // Check if ranges overlap\n  return !(end1 < start2 || end2 < start1);\n}\n\n/**\n * Validate that multiple CIDRs don't overlap\n *\n * @param cidrs - Array of CIDR blocks to check\n * @returns Validation result with details of any overlaps\n *\n * @example\n * const result = validateNoOverlaps([\n *   \"10.0.0.0/16\",\n *   \"10.1.0.0/16\",\n *   \"10.0.1.0/24\"\n * ]);\n * if (!result.valid) {\n *   console.error(\"Overlapping CIDRs:\", result.errors);\n * }\n */\nexport function validateNoOverlaps(cidrs: string[]): CidrValidationResult {\n  const errors: string[] = [];\n  const warnings: string[] = [];\n\n  // First validate each CIDR individually\n  for (const cidr of cidrs) {\n    const validation = validateCidr(cidr);\n    if (!validation.valid) {\n      errors.push(`Invalid CIDR ${cidr}: ${validation.errors.join(\", \")}`);\n    }\n  }\n\n  if (errors.length > 0) {\n    return { valid: false, errors, warnings };\n  }\n\n  // Check for overlaps\n  for (let i = 0; i < cidrs.length; i++) {\n    for (let j = i + 1; j < cidrs.length; j++) {\n      if (checkOverlap(cidrs[i], cidrs[j])) {\n        errors.push(`CIDRs overlap: ${cidrs[i]} and ${cidrs[j]}`);\n      }\n    }\n  }\n\n  return { valid: errors.length === 0, errors, warnings };\n}\n\n/**\n * Check if a child CIDR is contained within a parent CIDR\n *\n * @param parentCidr - Parent CIDR block\n * @param childCidr - Child CIDR block to check\n * @returns True if child is fully contained in parent\n *\n * @example\n * const contained = isContained(\"10.0.0.0/16\", \"10.0.1.0/24\");\n * console.log(contained); // true\n */\nexport function isContained(parentCidr: string, childCidr: string): boolean {\n  const parent = parseCidr(parentCidr);\n  const child = parseCidr(childCidr);\n\n  const parentStart = ipToNumber(parent.firstIp);\n  const parentEnd = ipToNumber(parent.lastIp);\n  const childStart = ipToNumber(child.firstIp);\n  const childEnd = ipToNumber(child.lastIp);\n\n  // Child must be fully within parent range\n  return childStart >= parentStart && childEnd <= parentEnd;\n}\n\n/**\n * Validate that multiple child CIDRs are all contained within a parent CIDR\n *\n * @param parentCidr - Parent CIDR block\n * @param childCidrs - Array of child CIDR blocks\n * @returns Validation result with details of any containment violations\n *\n * @example\n * const result = validateContainment(\"10.0.0.0/16\", [\n *   \"10.0.1.0/24\",\n *   \"10.0.2.0/24\"\n * ]);\n * if (!result.valid) {\n *   console.error(\"Containment violations:\", result.errors);\n * }\n */\nexport function validateContainment(\n  parentCidr: string,\n  childCidrs: string[],\n): CidrValidationResult {\n  const errors: string[] = [];\n  const warnings: string[] = [];\n\n  // Validate parent CIDR\n  const parentValidation = validateCidr(parentCidr);\n  if (!parentValidation.valid) {\n    errors.push(\n      `Invalid parent CIDR ${parentCidr}: ${parentValidation.errors.join(\", \")}`,\n    );\n    return { valid: false, errors, warnings };\n  }\n\n  // Validate each child CIDR\n  for (const childCidr of childCidrs) {\n    const childValidation = validateCidr(childCidr);\n    if (!childValidation.valid) {\n      errors.push(\n        `Invalid child CIDR ${childCidr}: ${childValidation.errors.join(\", \")}`,\n      );\n      continue;\n    }\n\n    // Check containment\n    if (!isContained(parentCidr, childCidr)) {\n      errors.push(\n        `Child CIDR ${childCidr} is not contained within parent CIDR ${parentCidr}`,\n      );\n    }\n  }\n\n  return { valid: errors.length === 0, errors, warnings };\n}\n\n/**\n * Convert an IP address string to a 32-bit number\n *\n * @param ip - IP address string (e.g., \"10.0.0.1\")\n * @returns 32-bit number representation\n *\n * @example\n * const num = ipToNumber(\"10.0.0.1\");\n * console.log(num); // 167772161\n */\nexport function ipToNumber(ip: string): number {\n  const octets = ip.split(\".\").map(Number);\n  return (\n    ((octets[0] << 24) >>> 0) +\n    ((octets[1] << 16) >>> 0) +\n    ((octets[2] << 8) >>> 0) +\n    octets[3]\n  );\n}\n\n/**\n * Convert a 32-bit number to an IP address string\n *\n * @param num - 32-bit number representation\n * @returns IP address string\n *\n * @example\n * const ip = numberToIp(167772161);\n * console.log(ip); // \"10.0.0.1\"\n */\nexport function numberToIp(num: number): string {\n  return [\n    (num >>> 24) & 0xff,\n    (num >>> 16) & 0xff,\n    (num >>> 8) & 0xff,\n    num & 0xff,\n  ].join(\".\");\n}\n\n/**\n * Convert a prefix length to a netmask number\n *\n * @param prefix - Prefix length (0-32)\n * @returns 32-bit netmask number\n *\n * @example\n * const mask = prefixToMask(24);\n * const maskIp = numberToIp(mask);\n * console.log(maskIp); // \"255.255.255.0\"\n */\nexport function prefixToMask(prefix: number): number {\n  return prefix === 0 ? 0 : (0xffffffff << (32 - prefix)) >>> 0;\n}\n"]}