/**
 * Represents an IPv4 address from a 'literal' value.
 * Examples:
 * - String: "10.0.0.0"
 * - Number: 167772160
 * - Octet Array: [10, 0, 0, 0]
 */
type Ipv4AddressLiteral = string | number | number[];
/**
 * Represents an IPv4 address in string format (uses stricter typescript type).
 */
type Ipv4AddressString = `${number}.${number}.${number}.${number}`;
/**
 * Represents an IPv4 address as an array of four octets.
 */
type Ipv4AddressOctets = [number, number, number, number];
/**
 * Represents an IPv4 CIDR from a 'literal' value.
 * Examples:
 * - String: "10.0.0.0/24"
 * - Object: { address: "10.0.0.0", range: 24 }
 * - Tuple: [[10, 0, 0, 0], 24]
 */
type Ipv4CidrLiteral = string | {
    address: Ipv4AddressLiteral;
    range: number;
} | [Ipv4AddressLiteral, number];
/**
 * Represents an IPv4 CIDR in string format (uses stricter typescript type).
 */
type Ipv4CidrString = `${number}.${number}.${number}.${number}/${number}`;

/**
 * Represents an IPv4 address with utility methods for manipulation and comparison.
 *
 * While you can instantiate this class directly, it is recommended to use the
 * {@link ipv4.address} shorthand method from the `ipv4` namespace instead.
 *
 * @example Creating addresses (prefer the shorthand)
 * ```ts
 * import { ipv4 } from 'cidr-block';
 *
 * // Recommended: use the ipv4 namespace shorthand
 * const addr1 = ipv4.address("192.168.1.1");
 * const addr2 = ipv4.address(3232235777);
 * const addr3 = ipv4.address([192, 168, 1, 1]);
 * ```
 *
 * @example Converting between formats
 * ```ts
 * import { ipv4 } from 'cidr-block';
 *
 * const addr = ipv4.address("192.168.1.1");
 * addr.toString();       // "192.168.1.1"
 * addr.toNumber();       // 3232235777
 * addr.octets();         // [192, 168, 1, 1]
 * addr.toBinaryString(); // "11000000.10101000.00000001.00000001"
 * ```
 *
 * @example Comparing addresses
 * ```ts
 * import { ipv4 } from 'cidr-block';
 *
 * const addr = ipv4.address("192.168.1.1");
 * addr.equals("192.168.1.1");      // true
 * addr.isGreaterThan("192.168.1.0"); // true
 * addr.isLessThan("192.168.1.2");    // true
 * ```
 *
 * @example Navigating sequential addresses
 * ```ts
 * import { ipv4 } from 'cidr-block';
 *
 * const addr = ipv4.address("192.168.1.1");
 * addr.nextAddress()?.toString();     // "192.168.1.2"
 * addr.previousAddress()?.toString(); // "192.168.1.0"
 * ```
 *
 * @example Checking address types
 * ```ts
 * import { ipv4 } from 'cidr-block';
 *
 * ipv4.address("127.0.0.1").isLoopbackAddress();  // true
 * ipv4.address("10.0.0.1").isPrivateAddress();    // true
 * ipv4.address("169.254.1.1").isLocalLinkAddress(); // true
 * ipv4.address("224.0.0.1").isMulticastAddress(); // true
 * ```
 */
declare class Ipv4Address {
    #private;
    constructor(ip: Ipv4AddressLiteral);
    /**
     * Gets the octets of the IPv4 address.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const addr = ipv4.address("192.168.1.1");
     * addr.octets(); // [192, 168, 1, 1]
     * ```
     *
     * @returns An array of four numbers representing the octets of the IPv4 address.
     */
    octets(): Ipv4AddressOctets;
    /**
     * Returns the string representation of the IPv4 address.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const addr = ipv4.address([10, 0, 0, 1]);
     * addr.toString(); // "10.0.0.1"
     * ```
     *
     * @returns The IPv4 address as a string in dotted-decimal notation (example: "192.187.0.1").
     */
    toString(): Ipv4AddressString;
    /**
     * Returns the binary string representation of the IPv4 address.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const addr = ipv4.address("192.168.1.1");
     * addr.toBinaryString(); // "11000000.10101000.00000001.00000001"
     * ```
     *
     * @returns The IPv4 address as a binary string in dotted-decimal notation (example: "11000000.10111011.00000000.00000001").
     */
    toBinaryString(): string;
    /**
     * Converts the IPv4 address to its numeric representation.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const addr = ipv4.address("192.168.1.1");
     * addr.toNumber(); // 3232235777
     * ```
     *
     * @returns The IPv4 address as a number.
     */
    toNumber(): number;
    /**
     * Checks if there is a next sequential IPv4 address.
     * This would only return false if the current address is the maximum possible value (255.255.255.255).
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * ipv4.address("192.168.1.1").hasNextAddress();     // true
     * ipv4.address("255.255.255.255").hasNextAddress(); // false
     * ```
     *
     * @returns true if there is a next IPv4 address.
     */
    hasNextAddress(): boolean;
    /**
     * Gets the next sequential IPv4 address.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const addr = ipv4.address("192.168.1.1");
     * addr.nextAddress()?.toString(); // "192.168.1.2"
     *
     * const maxAddr = ipv4.address("255.255.255.255");
     * maxAddr.nextAddress(); // undefined
     * ```
     *
     * @returns The next IPv4 address, or undefined if the current address is the maximum possible value.
     */
    nextAddress(): Ipv4Address | undefined;
    /**
     * Checks if there is a previous sequential IPv4 address.
     * This would only return false if the current address is the minimum possible value (0.0.0.0).
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * ipv4.address("192.168.1.1").hasPreviousAddress(); // true
     * ipv4.address("0.0.0.0").hasPreviousAddress();     // false
     * ```
     *
     * @returns true if there is a previous IPv4 address.
     */
    hasPreviousAddress(): boolean;
    /**
     * Gets the previous sequential IPv4 address.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const addr = ipv4.address("192.168.1.1");
     * addr.previousAddress()?.toString(); // "192.168.1.0"
     *
     * const minAddr = ipv4.address("0.0.0.0");
     * minAddr.previousAddress(); // undefined
     * ```
     *
     * @returns The previous IPv4 address, or undefined if the current address is the minimum possible value.
     */
    previousAddress(): Ipv4Address | undefined;
    /**
     * Compares two IPv4 addresses for equality.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const addr = ipv4.address("192.168.1.1");
     * addr.equals("192.168.1.1");         // true
     * addr.equals([192, 168, 1, 1]);      // true
     * addr.equals(ipv4.address("10.0.0.1")); // false
     * ```
     *
     * @param otherAddress - The other IPv4 address to compare with, which can be an Ipv4Address instance or literal value.
     * @returns true if both IPv4 addresses are equal
     */
    equals(otherAddress: Ipv4Address | Ipv4AddressLiteral): boolean;
    /**
     * Compares if this IPv4 address is greater than another IPv4 address.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const addr = ipv4.address("192.168.1.1");
     * addr.isGreaterThan("192.168.1.0"); // true
     * addr.isGreaterThan("192.168.1.1"); // false
     * addr.isGreaterThan("192.168.1.2"); // false
     * ```
     *
     * @param otherAddress - The other IPv4 address to compare with, which can be an Ipv4Address instance or literal value.
     * @returns true if this IPv4 address is greater than the other IPv4 address
     */
    isGreaterThan(otherAddress: Ipv4Address | Ipv4AddressLiteral): boolean;
    /**
     * Compares if this IPv4 address is greater than or equal to another IPv4 address.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const addr = ipv4.address("192.168.1.1");
     * addr.isGreaterThanOrEqual("192.168.1.0"); // true
     * addr.isGreaterThanOrEqual("192.168.1.1"); // true
     * addr.isGreaterThanOrEqual("192.168.1.2"); // false
     * ```
     *
     * @param otherAddress - The other IPv4 address to compare with, which can be an Ipv4Address instance or literal value.
     * @returns true if this IPv4 address is greater than or equal to the other IPv4 address
     */
    isGreaterThanOrEqual(otherAddress: Ipv4Address | Ipv4AddressLiteral): boolean;
    /**
     * Compares if this IPv4 address is less than another IPv4 address.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const addr = ipv4.address("192.168.1.1");
     * addr.isLessThan("192.168.1.2"); // true
     * addr.isLessThan("192.168.1.1"); // false
     * addr.isLessThan("192.168.1.0"); // false
     * ```
     *
     * @param otherAddress - The other IPv4 address to compare with, which can be an Ipv4Address instance or literal value.
     * @returns true if this IPv4 address is less than the other IPv4 address
     */
    isLessThan(otherAddress: Ipv4Address | Ipv4AddressLiteral): boolean;
    /**
     * Compares if this IPv4 address is less than or equal to another IPv4 address.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const addr = ipv4.address("192.168.1.1");
     * addr.isLessThanOrEqual("192.168.1.2"); // true
     * addr.isLessThanOrEqual("192.168.1.1"); // true
     * addr.isLessThanOrEqual("192.168.1.0"); // false
     * ```
     *
     * @param otherAddress - The other IPv4 address to compare with, which can be an Ipv4Address instance or literal value.
     * @returns true if this IPv4 address is less than or equal to the other IPv4 address
     */
    isLessThanOrEqual(otherAddress: Ipv4Address | Ipv4AddressLiteral): boolean;
    /**
     * Checks if the IPv4 address is a loopback address (in the CIDR of 127.0.0.0/8)
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * ipv4.address("127.0.0.1").isLoopbackAddress();   // true
     * ipv4.address("127.255.0.1").isLoopbackAddress(); // true
     * ipv4.address("192.168.1.1").isLoopbackAddress(); // false
     * ```
     *
     * @returns true if the IPv4 address is a loopback address (example: 127.0.0.1 is true)
     */
    isLoopbackAddress(): boolean;
    /**
     * Checks if the IPv4 address is a private address.
     *
     * This is based on RFC 1918, which defines the following private address ranges:
     * - 10.0.0.0/8
     * - 172.16.0.0/12
     * - 192.168.0.0/16
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * ipv4.address("10.0.0.1").isPrivateAddress();     // true
     * ipv4.address("172.16.0.1").isPrivateAddress();   // true
     * ipv4.address("192.168.1.1").isPrivateAddress();  // true
     * ipv4.address("8.8.8.8").isPrivateAddress();      // false
     * ```
     *
     * @returns true if the IPv4 address is in any of the private address ranges.
     */
    isPrivateAddress(): boolean;
    /**
     * Checks if the IPv4 address is a local-link address (in the CIDR of 169.254.0.0/16).
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * ipv4.address("169.254.1.1").isLocalLinkAddress();   // true
     * ipv4.address("169.254.255.255").isLocalLinkAddress(); // true
     * ipv4.address("192.168.1.1").isLocalLinkAddress();   // false
     * ```
     *
     * @returns true if the IPv4 address is a local-link address.
     */
    isLocalLinkAddress(): boolean;
    /**
     * Checks if the IPv4 address is a multicast address (between 224.0.0.0 to 239.255.255.255).
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * ipv4.address("224.0.0.1").isMulticastAddress();   // true
     * ipv4.address("239.255.255.255").isMulticastAddress(); // true
     * ipv4.address("192.168.1.1").isMulticastAddress(); // false
     * ```
     *
     * @returns true if the IPv4 address is a multicast address.
     */
    isMulticastAddress(): boolean;
}

/**
 * Represents an IPv4 CIDR block with utility methods for subnet operations.
 *
 * While you can instantiate this class directly, it is recommended to use the
 * {@link ipv4.cidr} shorthand method from the `ipv4` namespace instead.
 *
 * @example Creating CIDR blocks (prefer the shorthand)
 * ```ts
 * import { ipv4 } from 'cidr-block';
 *
 * // Recommended: use the ipv4 namespace shorthand
 * const cidr1 = ipv4.cidr("192.168.0.0/24");
 * const cidr2 = ipv4.cidr({ address: "10.0.0.0", range: 8 });
 * const cidr3 = ipv4.cidr([[172, 16, 0, 0], 12]);
 * ```
 *
 * @example Getting CIDR properties
 * ```ts
 * import { ipv4 } from 'cidr-block';
 *
 * const cidr = ipv4.cidr("192.168.0.0/24");
 * cidr.baseAddress().toString(); // "192.168.0.0"
 * cidr.range();                  // 24
 * cidr.netmask().toString();     // "255.255.255.0"
 * cidr.network().toString();     // "192.168.0.0"
 * cidr.addressCount();           // 256
 * ```
 *
 * @example Working with usable addresses
 * ```ts
 * import { ipv4 } from 'cidr-block';
 *
 * const cidr = ipv4.cidr("192.168.0.0/24");
 * cidr.getFirstUsableAddress()?.toString(); // "192.168.0.1"
 * cidr.getLastUsableAddress()?.toString();  // "192.168.0.254"
 * ```
 *
 * @example Iterating over addresses
 * ```ts
 * import { ipv4 } from 'cidr-block';
 *
 * const cidr = ipv4.cidr("192.168.1.0/30");
 * for (const addr of cidr.addresses()) {
 *   console.log(addr.toString());
 * }
 * // "192.168.1.0", "192.168.1.1", "192.168.1.2", "192.168.1.3"
 * ```
 *
 * @example Checking containment and overlap
 * ```ts
 * import { ipv4 } from 'cidr-block';
 *
 * const cidr = ipv4.cidr("192.168.0.0/24");
 * cidr.includes(ipv4.address("192.168.0.100")); // true
 * cidr.includes(ipv4.address("192.168.1.1"));   // false
 * cidr.overlaps("192.168.0.0/25");              // true
 * cidr.overlaps("10.0.0.0/8");                  // false
 * ```
 *
 * @example Splitting into subranges
 * ```ts
 * import { ipv4 } from 'cidr-block';
 *
 * const cidr = ipv4.cidr("192.168.0.0/24");
 *
 * // Split into equal /26 subnets
 * cidr.subnet(26).map(s => s.toString());
 * // ["192.168.0.0/26", "192.168.0.64/26", "192.168.0.128/26", "192.168.0.192/26"]
 *
 * // Split by specific ranges
 * cidr.subnetBy([25, 26, 27, 27]).map(s => s.toString());
 * // ["192.168.0.0/25", "192.168.0.128/26", "192.168.0.192/27", "192.168.0.224/27"]
 * ```
 *
 * @example Navigating sequential CIDRs
 * ```ts
 * import { ipv4 } from 'cidr-block';
 *
 * const cidr = ipv4.cidr("192.168.0.0/24");
 * cidr.nextCIDR()?.toString();     // "192.168.1.0/24"
 * cidr.previousCIDR()?.toString(); // "192.167.255.0/24"
 * ```
 */
declare class Ipv4Cidr {
    #private;
    constructor(address: Ipv4CidrLiteral);
    /**
     * Gets the base IPv4 address of the CIDR.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const cidr = ipv4.cidr("192.168.0.0/24");
     * cidr.baseAddress().toString(); // "192.168.0.0"
     * ```
     *
     * @returns The base IPv4 address.
     */
    baseAddress(): Ipv4Address;
    /**
     * Gets the CIDR range.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const cidr = ipv4.cidr("192.168.0.0/24");
     * cidr.range(); // 24
     * ```
     *
     * @returns The CIDR range as a number.
     */
    range(): number;
    /**
     * Calculates the netmask for the CIDR range.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * ipv4.cidr("192.168.0.0/24").netmask().toString(); // "255.255.255.0"
     * ipv4.cidr("10.0.0.0/8").netmask().toString();     // "255.0.0.0"
     * ipv4.cidr("172.16.0.0/16").netmask().toString();  // "255.255.0.0"
     * ```
     *
     * @returns The netmask as an Ipv4Address.
     */
    netmask(): Ipv4Address;
    /**
     * Calculates the hostmask (inverse of the netmask) for the CIDR range.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * ipv4.cidr("192.168.0.0/24").hostmask().toString(); // "0.0.0.255"
     * ipv4.cidr("10.0.0.0/8").hostmask().toString();     // "0.255.255.255"
     * ipv4.cidr("172.16.0.0/16").hostmask().toString();  // "0.0.255.255"
     * ```
     *
     * @returns The hostmask as an Ipv4Address.
     */
    hostmask(): Ipv4Address;
    /**
     * Calculates the network address by applying the netmask to the base address.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * ipv4.cidr("192.168.1.5/24").network().toString(); // "192.168.1.0"
     * ipv4.cidr("10.5.10.20/8").network().toString();   // "10.0.0.0"
     * ipv4.cidr("172.16.5.1/16").network().toString();  // "172.16.0.0"
     * ```
     *
     * @returns The network address as an Ipv4Address.
     */
    network(): Ipv4Address;
    /**
     * Calculates the network CIDR by applying the netmask to the base address and returning a CIDR with the network address.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * ipv4.cidr("192.168.1.5/24").networkCIDR().toString(); // "192.168.1.0/24"
     * ipv4.cidr("10.5.10.20/8").networkCIDR().toString();   // "10.0.0.0/8"
     * ipv4.cidr("172.16.5.1/16").networkCIDR().toString();  // "172.16.0.0/16"
     * ```
     *
     * @returns The network CIDR as an Ipv4Cidr.
     */
    networkCIDR(): Ipv4Cidr;
    /**
     * Returns the string representation of the IPv4 CIDR.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const cidr = ipv4.cidr({ address: "10.0.0.0", range: 8 });
     * cidr.toString(); // "10.0.0.0/8"
     * ```
     *
     * @returns The IPv4 CIDR as a string (example: "192.0.0.0/24").
     */
    toString(): Ipv4CidrString;
    /**
     * Gets the address and range parts of the IPv4 CIDR.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const [address, range] = ipv4.cidr("192.168.0.0/24").rangeParts();
     * address.toString(); // "192.168.0.0"
     * range; // 24
     * ```
     *
     * @returns A tuple containing the IPv4 address and the CIDR range.
     */
    rangeParts(): [Ipv4Address, number];
    /**
     * Calculates the total number of addresses in the CIDR range.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * ipv4.cidr("192.168.0.0/24").addressCount(); // 256
     * ipv4.cidr("10.0.0.0/8").addressCount();     // 16777216
     * ipv4.cidr("192.168.1.0/32").addressCount(); // 1
     * ```
     *
     * @returns The total number of addresses in the CIDR range.
     */
    addressCount(): number;
    /**
     * Generates all IPv4 addresses within the CIDR range.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const cidr = ipv4.cidr("192.168.1.0/30");
     * for (const addr of cidr.addresses()) {
     *   console.log(addr.toString());
     * }
     * // Output: "192.168.1.0", "192.168.1.1", "192.168.1.2", "192.168.1.3"
     * ```
     *
     * @returns A generator that yields each IPv4 address in the CIDR range.
     */
    addresses(): Generator<Ipv4Address>;
    /**
     * Checks if this CIDR is equal to another CIDR.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const cidr = ipv4.cidr("192.168.0.0/24");
     * cidr.equals("192.168.0.0/24");                     // true
     * cidr.equals({ address: "192.168.0.0", range: 24 }); // true
     * cidr.equals("10.0.0.0/8");                         // false
     * ```
     *
     * @param other - The other IPv4 CIDR to compare with.
     * @returns True if both CIDRs have the same base address and range; otherwise, false.
     */
    equals(other: Ipv4Cidr | Ipv4CidrLiteral): boolean;
    /**
     * Checks if there is a next sequential CIDR.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * ipv4.cidr("192.168.0.0/24").hasNextCIDR(); // true
     * ipv4.cidr("255.255.255.0/24").hasNextCIDR(); // false
     * ```
     *
     * @returns true if there is a next CIDR.
     */
    hasNextCIDR(): boolean;
    /**
     * Gets the next sequential CIDR.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const cidr = ipv4.cidr("192.168.0.0/24");
     * cidr.nextCIDR()?.toString(); // "192.168.1.0/24"
     *
     * const lastCidr = ipv4.cidr("255.255.255.0/24");
     * lastCidr.nextCIDR(); // undefined
     * ```
     *
     * @returns The next CIDR, or undefined if there is no next CIDR.
     */
    nextCIDR(): Ipv4Cidr | undefined;
    /**
     * Checks if there is a previous sequential CIDR.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * ipv4.cidr("192.168.1.0/24").hasPreviousCIDR(); // true
     * ipv4.cidr("0.0.0.0/24").hasPreviousCIDR();     // false
     * ```
     *
     * @returns true if there is a previous CIDR.
     */
    hasPreviousCIDR(): boolean;
    /**
     * Gets the previous sequential CIDR.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const cidr = ipv4.cidr("192.168.1.0/24");
     * cidr.previousCIDR()?.toString(); // "192.168.0.0/24"
     *
     * const firstCidr = ipv4.cidr("0.0.0.0/24");
     * firstCidr.previousCIDR(); // undefined
     * ```
     *
     * @returns The previous CIDR, or undefined if there is no previous CIDR.
     */
    previousCIDR(): Ipv4Cidr | undefined;
    /**
     * Gets the first usable address in the CIDR range.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const cidr = ipv4.cidr("192.168.0.0/24");
     * cidr.getFirstUsableAddress()?.toString(); // "192.168.0.1"
     *
     * const hostCidr = ipv4.cidr("192.168.1.1/32");
     * hostCidr.getFirstUsableAddress(); // undefined (no usable addresses in /32)
     * ```
     *
     * @returns The first usable IPv4 address, or undefined if the range is /32.
     */
    getFirstUsableAddress(): Ipv4Address | undefined;
    /**
     * Gets the last usable address in the CIDR range.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const cidr = ipv4.cidr("192.168.0.0/24");
     * cidr.getLastUsableAddress()?.toString(); // "192.168.0.254"
     *
     * const hostCidr = ipv4.cidr("192.168.1.1/32");
     * hostCidr.getLastUsableAddress(); // undefined (no usable addresses in /32)
     * ```
     *
     * @returns The last usable IPv4 address, or undefined if the range is /32.
     */
    getLastUsableAddress(): Ipv4Address | undefined;
    /**
     * Checks if the given IPv4 address is within the CIDR range.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const cidr = ipv4.cidr("192.168.0.0/24");
     * cidr.includes(ipv4.address("192.168.0.100")); // true
     * cidr.includes(ipv4.address("192.168.1.1"));   // false
     * ```
     *
     * @param ip - The IPv4 address to check.
     * @returns True if the address is within the CIDR range; otherwise, false.
     */
    includes(ip: Ipv4Address): boolean;
    /**
     * Checks if this CIDR overlaps with another CIDR.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const cidr = ipv4.cidr("192.168.0.0/24");
     * cidr.overlaps("192.168.0.0/25");  // true (subset)
     * cidr.overlaps("192.168.0.128/25"); // true (partial overlap)
     * cidr.overlaps("10.0.0.0/8");      // false (no overlap)
     * ```
     *
     * @param other - The other IPv4 CIDR to check for overlap.
     * @returns True if the CIDRs overlap; otherwise, false.
     */
    overlaps(other: Ipv4Cidr | Ipv4CidrLiteral): boolean;
    /**
     * Splits the CIDR into smaller subranges of the specified new range.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const cidr = ipv4.cidr("192.168.0.0/24");
     * const subnets = cidr.subnet(26);
     * subnets.map(s => s.toString());
     * // ["192.168.0.0/26", "192.168.0.64/26", "192.168.0.128/26", "192.168.0.192/26"]
     * ```
     *
     * @param newRange - The new CIDR range for the subnets.
     * @returns An array of Ipv4Cidr instances representing the subnets.
     * @throws InvalidIpv4CidrRangeError if the new range is less than the current range or greater than the maximum range.
     */
    subnet(newRange: number): Ipv4Cidr[];
    /**
     * Splits the CIDR into sequential subranges with the specified CIDR ranges.
     * Each range in the input array creates a subrange starting where the previous one ended.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const cidr = ipv4.cidr("10.0.0.0/16");
     * const subnets = cidr.subnetBy([24, 20, 24]);
     * subnets.map(s => s.toString());
     * // ["10.0.0.0/24", "10.0.1.0/20", "10.0.17.0/24"]
     * ```
     *
     * @param ranges - An array of CIDR range values (e.g., [24, 20, 24]).
     * @returns An array of Ipv4Cidr instances representing the subnets.
     * @throws InvalidIpv4CidrRangeError if any range is less than the current range or greater than 32.
     */
    subnetBy(ranges: number[]): Ipv4Cidr[];
}

declare class InvalidIpv4AddressError extends Error {
    name: string;
    constructor(invalidAddress: unknown);
}
declare class InvalidIpv4CidrError extends Error {
    name: string;
    constructor(invalidCidr: unknown);
}
declare class InvalidIpv4CidrRangeError extends Error {
    name: string;
}

declare namespace ipv4 {
    /**
     * The maximum possible value for an IPv4 address.
     */
    const MAX_SIZE = 4294967295;
    /**
     * The minimum possible value for an IPv4 address.
     */
    const MIN_SIZE = 0;
    /**
     * The maximum CIDR range for IPv4 addresses.
     */
    const MAX_RANGE = 32;
    /**
     * The minimum CIDR range for IPv4 addresses.
     */
    const MIN_RANGE = 0;
    /**
     * Creates a new Ipv4Address instance from the given literal.
     * Valid formats include string, number, or octet array.
     *
     * @example Creating addresses
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const addr1 = ipv4.address("192.168.1.1");
     * const addr2 = ipv4.address(3232235777);
     * const addr3 = ipv4.address([192, 168, 1, 1]);
     * ```
     *
     * @example Converting between formats
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const addr = ipv4.address("192.168.1.1");
     * addr.toString();       // "192.168.1.1"
     * addr.toNumber();       // 3232235777
     * addr.octets();         // [192, 168, 1, 1]
     * addr.toBinaryString(); // "11000000.10101000.00000001.00000001"
     * ```
     *
     * @example Comparing addresses
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const addr = ipv4.address("192.168.1.1");
     * addr.equals("192.168.1.1");      // true
     * addr.isGreaterThan("192.168.1.0"); // true
     * addr.isLessThan("192.168.1.2");    // true
     * ```
     *
     * @example Navigating sequential addresses
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const addr = ipv4.address("192.168.1.1");
     * addr.nextAddress()?.toString();     // "192.168.1.2"
     * addr.previousAddress()?.toString(); // "192.168.1.0"
     * ```
     *
     * @example Checking address types
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * ipv4.address("127.0.0.1").isLoopbackAddress();  // true
     * ipv4.address("10.0.0.1").isPrivateAddress();    // true
     * ipv4.address("169.254.1.1").isLocalLinkAddress(); // true
     * ipv4.address("224.0.0.1").isMulticastAddress(); // true
     * ```
     *
     * @param ip - The IPv4 address in string, number, or octet array format.
     * @returns A new Ipv4Address instance.
     * @throws {InvalidIpv4AddressError} If the input is not a valid IPv4 address.
     */
    function address(ip: Ipv4AddressLiteral): Ipv4Address;
    /**
     * Creates a new Ipv4Cidr instance from the given literal.
     * Valid formats include string, object, or tuple.
     *
     * @example Creating CIDR blocks
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const cidr1 = ipv4.cidr("192.168.0.0/24");
     * const cidr2 = ipv4.cidr({ address: "10.0.0.0", range: 8 });
     * const cidr3 = ipv4.cidr([[172, 16, 0, 0], 12]);
     * ```
     *
     * @example Getting CIDR properties
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const cidr = ipv4.cidr("192.168.0.0/24");
     * cidr.baseAddress().toString(); // "192.168.0.0"
     * cidr.range();                  // 24
     * cidr.netmask().toString();     // "255.255.255.0"
     * cidr.addressCount();           // 256
     * ```
     *
     * @example Working with usable addresses
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const cidr = ipv4.cidr("192.168.0.0/24");
     * cidr.getFirstUsableAddress()?.toString(); // "192.168.0.1"
     * cidr.getLastUsableAddress()?.toString();  // "192.168.0.254"
     * ```
     *
     * @example Iterating over addresses
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const cidr = ipv4.cidr("192.168.1.0/30");
     * for (const addr of cidr.addresses()) {
     *   console.log(addr.toString());
     * }
     * // "192.168.1.0", "192.168.1.1", "192.168.1.2", "192.168.1.3"
     * ```
     *
     * @example Checking containment and overlap
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const cidr = ipv4.cidr("192.168.0.0/24");
     * cidr.includes(ipv4.address("192.168.0.100")); // true
     * cidr.includes(ipv4.address("192.168.1.1"));   // false
     * cidr.overlaps("192.168.0.0/25");              // true
     * cidr.overlaps("10.0.0.0/8");                  // false
     * ```
     *
     * @example Splitting into subranges
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const cidr = ipv4.cidr("192.168.0.0/24");
     *
     * // Split into equal /26 subnets
     * cidr.subnet(26).map(s => s.toString());
     * // ["192.168.0.0/26", "192.168.0.64/26", "192.168.0.128/26", "192.168.0.192/26"]
     *
     * // Split by specific ranges
     * cidr.subnetBy([25, 26, 27, 27]).map(s => s.toString());
     * // ["192.168.0.0/25", "192.168.0.128/26", "192.168.0.192/27", "192.168.0.224/27"]
     * ```
     *
     * @example Navigating sequential CIDRs
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * const cidr = ipv4.cidr("192.168.0.0/24");
     * cidr.nextCIDR()?.toString();     // "192.168.1.0/24"
     * cidr.previousCIDR()?.toString(); // "192.167.255.0/24"
     * ```
     *
     * @param cidr - The IPv4 CIDR in string, object, or tuple format.
     * @returns A new Ipv4Cidr instance.
     * @throws {InvalidIpv4CidrError} If the input is not a valid IPv4 CIDR.
     */
    function cidr(cidr: Ipv4CidrLiteral): Ipv4Cidr;
    /**
     * Validates whether the given input is a valid IPv4 address.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * ipv4.isValidAddress("192.168.1.1");   // true
     * ipv4.isValidAddress("256.0.0.1");     // false (octet out of range)
     * ipv4.isValidAddress(3232235777);      // true
     * ipv4.isValidAddress([192, 168, 1, 1]); // true
     * ipv4.isValidAddress("invalid");       // false
     * ```
     *
     * @param ip - The IPv4 address to validate, which can be in string, number, or octet array format.
     * @returns True if the input is a valid IPv4 address; otherwise, false.
     */
    function isValidAddress(ip: Ipv4AddressLiteral): boolean;
    /**
     * Validates whether the given input is a valid IPv4 CIDR.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * ipv4.isValidCIDR("192.168.0.0/24");                  // true
     * ipv4.isValidCIDR("192.168.0.0/33");                  // false (range out of bounds)
     * ipv4.isValidCIDR({ address: "10.0.0.0", range: 8 }); // true
     * ipv4.isValidCIDR([[172, 16, 0, 0], 12]);             // true
     * ipv4.isValidCIDR("invalid/24");                      // false
     * ```
     *
     * @param cidr - The IPv4 CIDR to validate, which can be in string, object, or tuple format.
     * @returns True if the input is a valid IPv4 CIDR; otherwise, false.
     */
    function isValidCIDR(cidr: Ipv4CidrLiteral): boolean;
    /**
     * Parses the given IPv4 address into its octet representation.
     *
     * @example
     * ```ts
     * import { ipv4 } from 'cidr-block';
     *
     * ipv4.parseOctets("192.168.1.1");   // [192, 168, 1, 1]
     * ipv4.parseOctets(3232235777);      // [192, 168, 1, 1]
     * ipv4.parseOctets([10, 0, 0, 1]);   // [10, 0, 0, 1]
     * ```
     *
     * @param ip - The IPv4 address to parse, which can be in string, number, or octet array format.
     * @returns {Ipv4AddressOctets} An array of four numbers representing the octets of the IPv4 address.
     * @throws {InvalidIpv4AddressError} If the input is not a valid IPv4 address.
     */
    function parseOctets(ip: Ipv4AddressLiteral): Ipv4AddressOctets;
}

/**
 * Represents an IPv6 address from a 'literal' value.
 * Examples:
 * - String: "2001:db8::1"
 * - BigInt: 42540766411282592856903984951653826561n
 * - Hextets Array: [0x2001, 0xdb8, 0, 0, 0, 0, 0, 1]
 */
type Ipv6AddressLiteral = string | bigint | number[];
/**
 * Represents an IPv6 address as an array of eight 16-bit hextets.
 */
type Ipv6AddressHextets = [number, number, number, number, number, number, number, number];
/**
 * Represents an IPv6 CIDR from a 'literal' value.
 * Examples:
 * - String: "2001:db8::/32"
 * - Object: { address: "2001:db8::", range: 32 }
 * - Tuple: ["2001:db8::", 32]
 */
type Ipv6CidrLiteral = string | {
    address: Ipv6AddressLiteral;
    range: number;
} | [Ipv6AddressLiteral, number];

/**
 * Represents an IPv6 address with utility methods for manipulation and comparison.
 *
 * While you can instantiate this class directly, it is recommended to use the
 * {@link ipv6.address} shorthand method from the `ipv6` namespace instead.
 *
 * @example Creating addresses (prefer the shorthand)
 * ```ts
 * import { ipv6 } from 'cidr-block';
 *
 * // Recommended: use the ipv6 namespace shorthand
 * const addr1 = ipv6.address("2001:db8::1");
 * const addr2 = ipv6.address(42540766411282592856903984951653826561n);
 * const addr3 = ipv6.address([0x2001, 0xdb8, 0, 0, 0, 0, 0, 1]);
 * ```
 *
 * @example Converting between formats
 * ```ts
 * import { ipv6 } from 'cidr-block';
 *
 * const addr = ipv6.address("2001:db8::1");
 * addr.toString();       // "2001:db8::1" (compressed)
 * addr.toFullString();   // "2001:0db8:0000:0000:0000:0000:0000:0001"
 * addr.toBigInt();       // 42540766411282592856903984951653826561n
 * addr.hextets();        // [0x2001, 0xdb8, 0, 0, 0, 0, 0, 1]
 * ```
 *
 * @example Comparing addresses
 * ```ts
 * import { ipv6 } from 'cidr-block';
 *
 * const addr = ipv6.address("2001:db8::1");
 * addr.equals("2001:db8::1");         // true
 * addr.isGreaterThan("2001:db8::0");  // true
 * addr.isLessThan("2001:db8::2");     // true
 * ```
 *
 * @example Navigating sequential addresses
 * ```ts
 * import { ipv6 } from 'cidr-block';
 *
 * const addr = ipv6.address("2001:db8::1");
 * addr.nextAddress()?.toString();     // "2001:db8::2"
 * addr.previousAddress()?.toString(); // "2001:db8::"
 * ```
 *
 * @example Checking address types
 * ```ts
 * import { ipv6 } from 'cidr-block';
 *
 * ipv6.address("::1").isLoopbackAddress();           // true
 * ipv6.address("fc00::1").isUniqueLocalAddress();    // true
 * ipv6.address("fe80::1").isLinkLocalAddress();      // true
 * ipv6.address("ff02::1").isMulticastAddress();      // true
 * ```
 */
declare class Ipv6Address {
    #private;
    constructor(ip: Ipv6AddressLiteral);
    /**
     * Gets the hextets of the IPv6 address.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const addr = ipv6.address("2001:db8::1");
     * addr.hextets(); // [0x2001, 0xdb8, 0, 0, 0, 0, 0, 1]
     * ```
     *
     * @returns An array of eight numbers representing the hextets of the IPv6 address.
     */
    hextets(): Ipv6AddressHextets;
    /**
     * Returns the full (expanded) string representation of the IPv6 address.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const addr = ipv6.address("2001:db8::1");
     * addr.toFullString(); // "2001:0db8:0000:0000:0000:0000:0000:0001"
     * ```
     *
     * @returns The IPv6 address as a full string with all hextets expanded.
     */
    toFullString(): string;
    /**
     * Returns the compressed string representation of the IPv6 address.
     * Uses :: notation for the longest run of consecutive zero hextets.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const addr = ipv6.address("2001:0db8:0000:0000:0000:0000:0000:0001");
     * addr.toString(); // "2001:db8::1"
     * ```
     *
     * @returns The IPv6 address as a compressed string.
     */
    toString(): string;
    /**
     * Returns the binary string representation of the IPv6 address.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const addr = ipv6.address("::1");
     * addr.toBinaryString();
     * // "0000000000000000:0000000000000000:0000000000000000:0000000000000000:0000000000000000:0000000000000000:0000000000000000:0000000000000001"
     * ```
     *
     * @returns The IPv6 address as a binary string with colons separating hextets.
     */
    toBinaryString(): string;
    /**
     * Converts the IPv6 address to its BigInt representation.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const addr = ipv6.address("2001:db8::1");
     * addr.toBigInt(); // 42540766411282592856903984951653826561n
     * ```
     *
     * @returns The IPv6 address as a BigInt.
     */
    toBigInt(): bigint;
    /**
     * Checks if there is a next sequential IPv6 address.
     * This would only return false if the current address is the maximum possible value.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * ipv6.address("2001:db8::1").hasNextAddress();                               // true
     * ipv6.address("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff").hasNextAddress();   // false
     * ```
     *
     * @returns true if there is a next IPv6 address.
     */
    hasNextAddress(): boolean;
    /**
     * Gets the next sequential IPv6 address.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const addr = ipv6.address("2001:db8::1");
     * addr.nextAddress()?.toString(); // "2001:db8::2"
     *
     * const maxAddr = ipv6.address("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
     * maxAddr.nextAddress(); // undefined
     * ```
     *
     * @returns The next IPv6 address, or undefined if the current address is the maximum possible value.
     */
    nextAddress(): Ipv6Address | undefined;
    /**
     * Checks if there is a previous sequential IPv6 address.
     * This would only return false if the current address is the minimum possible value (::).
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * ipv6.address("2001:db8::1").hasPreviousAddress(); // true
     * ipv6.address("::").hasPreviousAddress();          // false
     * ```
     *
     * @returns true if there is a previous IPv6 address.
     */
    hasPreviousAddress(): boolean;
    /**
     * Gets the previous sequential IPv6 address.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const addr = ipv6.address("2001:db8::1");
     * addr.previousAddress()?.toString(); // "2001:db8::"
     *
     * const minAddr = ipv6.address("::");
     * minAddr.previousAddress(); // undefined
     * ```
     *
     * @returns The previous IPv6 address, or undefined if the current address is the minimum possible value.
     */
    previousAddress(): Ipv6Address | undefined;
    /**
     * Compares two IPv6 addresses for equality.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const addr = ipv6.address("2001:db8::1");
     * addr.equals("2001:db8::1");                    // true
     * addr.equals("2001:0db8:0:0:0:0:0:1");          // true
     * addr.equals(ipv6.address("2001:db8::2"));      // false
     * ```
     *
     * @param otherAddress - The other IPv6 address to compare with, which can be an Ipv6Address instance or literal value.
     * @returns true if both IPv6 addresses are equal
     */
    equals(otherAddress: Ipv6Address | Ipv6AddressLiteral): boolean;
    /**
     * Compares if this IPv6 address is greater than another IPv6 address.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const addr = ipv6.address("2001:db8::1");
     * addr.isGreaterThan("2001:db8::");   // true
     * addr.isGreaterThan("2001:db8::1");  // false
     * addr.isGreaterThan("2001:db8::2");  // false
     * ```
     *
     * @param otherAddress - The other IPv6 address to compare with, which can be an Ipv6Address instance or literal value.
     * @returns true if this IPv6 address is greater than the other IPv6 address
     */
    isGreaterThan(otherAddress: Ipv6Address | Ipv6AddressLiteral): boolean;
    /**
     * Compares if this IPv6 address is greater than or equal to another IPv6 address.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const addr = ipv6.address("2001:db8::1");
     * addr.isGreaterThanOrEqual("2001:db8::");   // true
     * addr.isGreaterThanOrEqual("2001:db8::1");  // true
     * addr.isGreaterThanOrEqual("2001:db8::2");  // false
     * ```
     *
     * @param otherAddress - The other IPv6 address to compare with, which can be an Ipv6Address instance or literal value.
     * @returns true if this IPv6 address is greater than or equal to the other IPv6 address
     */
    isGreaterThanOrEqual(otherAddress: Ipv6Address | Ipv6AddressLiteral): boolean;
    /**
     * Compares if this IPv6 address is less than another IPv6 address.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const addr = ipv6.address("2001:db8::1");
     * addr.isLessThan("2001:db8::2");  // true
     * addr.isLessThan("2001:db8::1");  // false
     * addr.isLessThan("2001:db8::");   // false
     * ```
     *
     * @param otherAddress - The other IPv6 address to compare with, which can be an Ipv6Address instance or literal value.
     * @returns true if this IPv6 address is less than the other IPv6 address
     */
    isLessThan(otherAddress: Ipv6Address | Ipv6AddressLiteral): boolean;
    /**
     * Compares if this IPv6 address is less than or equal to another IPv6 address.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const addr = ipv6.address("2001:db8::1");
     * addr.isLessThanOrEqual("2001:db8::2");  // true
     * addr.isLessThanOrEqual("2001:db8::1");  // true
     * addr.isLessThanOrEqual("2001:db8::");   // false
     * ```
     *
     * @param otherAddress - The other IPv6 address to compare with, which can be an Ipv6Address instance or literal value.
     * @returns true if this IPv6 address is less than or equal to the other IPv6 address
     */
    isLessThanOrEqual(otherAddress: Ipv6Address | Ipv6AddressLiteral): boolean;
    /**
     * Checks if the IPv6 address is the loopback address (::1)
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * ipv6.address("::1").isLoopbackAddress();          // true
     * ipv6.address("2001:db8::1").isLoopbackAddress();  // false
     * ```
     *
     * @returns true if the IPv6 address is the loopback address
     */
    isLoopbackAddress(): boolean;
    /**
     * Checks if the IPv6 address is the unspecified address (::)
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * ipv6.address("::").isUnspecifiedAddress();          // true
     * ipv6.address("2001:db8::1").isUnspecifiedAddress(); // false
     * ```
     *
     * @returns true if the IPv6 address is the unspecified address
     */
    isUnspecifiedAddress(): boolean;
    /**
     * Checks if the IPv6 address is a unique local address (fc00::/7).
     * These are the IPv6 equivalent of RFC 1918 private addresses.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * ipv6.address("fc00::1").isUniqueLocalAddress();     // true
     * ipv6.address("fd00::1").isUniqueLocalAddress();     // true
     * ipv6.address("2001:db8::1").isUniqueLocalAddress(); // false
     * ```
     *
     * @returns true if the IPv6 address is a unique local address
     */
    isUniqueLocalAddress(): boolean;
    /**
     * Checks if the IPv6 address is a link-local address (fe80::/10)
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * ipv6.address("fe80::1").isLinkLocalAddress();     // true
     * ipv6.address("2001:db8::1").isLinkLocalAddress(); // false
     * ```
     *
     * @returns true if the IPv6 address is a link-local address
     */
    isLinkLocalAddress(): boolean;
    /**
     * Checks if the IPv6 address is a multicast address (ff00::/8)
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * ipv6.address("ff02::1").isMulticastAddress();     // true
     * ipv6.address("2001:db8::1").isMulticastAddress(); // false
     * ```
     *
     * @returns true if the IPv6 address is a multicast address
     */
    isMulticastAddress(): boolean;
    /**
     * Checks if the IPv6 address is an IPv4-mapped IPv6 address (::ffff:0:0/96)
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * ipv6.address("::ffff:192.168.1.1").isIPv4MappedAddress();  // true
     * ipv6.address("::ffff:c0a8:0101").isIPv4MappedAddress();    // true
     * ipv6.address("2001:db8::1").isIPv4MappedAddress();         // false
     * ```
     *
     * @returns true if the IPv6 address is an IPv4-mapped address
     */
    isIPv4MappedAddress(): boolean;
    /**
     * Checks if the IPv6 address is a documentation address (2001:db8::/32)
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * ipv6.address("2001:db8::1").isDocumentationAddress();     // true
     * ipv6.address("2001:db8:1234::1").isDocumentationAddress(); // true
     * ipv6.address("2001:470::1").isDocumentationAddress();     // false
     * ```
     *
     * @returns true if the IPv6 address is a documentation address
     */
    isDocumentationAddress(): boolean;
}

/**
 * Represents an IPv6 CIDR block with utility methods for subnet operations.
 *
 * While you can instantiate this class directly, it is recommended to use the
 * {@link ipv6.cidr} shorthand method from the `ipv6` namespace instead.
 *
 * @example Creating CIDR blocks (prefer the shorthand)
 * ```ts
 * import { ipv6 } from 'cidr-block';
 *
 * // Recommended: use the ipv6 namespace shorthand
 * const cidr1 = ipv6.cidr("2001:db8::/32");
 * const cidr2 = ipv6.cidr({ address: "2001:db8::", range: 32 });
 * const cidr3 = ipv6.cidr(["2001:db8::", 32]);
 * ```
 *
 * @example Getting CIDR properties
 * ```ts
 * import { ipv6 } from 'cidr-block';
 *
 * const cidr = ipv6.cidr("2001:db8::/32");
 * cidr.baseAddress().toString(); // "2001:db8::"
 * cidr.range();                  // 32
 * cidr.netmask().toString();     // "ffff:ffff::"
 * cidr.network().toString();     // "2001:db8::"
 * cidr.addressCount();           // 79228162514264337593543950336n
 * ```
 *
 * @example Working with usable addresses
 * ```ts
 * import { ipv6 } from 'cidr-block';
 *
 * const cidr = ipv6.cidr("2001:db8::/126");
 * cidr.getFirstUsableAddress()?.toString(); // "2001:db8::1"
 * cidr.getLastUsableAddress()?.toString();  // "2001:db8::2"
 * ```
 *
 * @example Checking containment and overlap
 * ```ts
 * import { ipv6 } from 'cidr-block';
 *
 * const cidr = ipv6.cidr("2001:db8::/32");
 * cidr.includes(ipv6.address("2001:db8::1"));  // true
 * cidr.includes(ipv6.address("2001:db9::1"));  // false
 * cidr.overlaps("2001:db8::/48");              // true
 * cidr.overlaps("2001:db9::/32");              // false
 * ```
 *
 * @example Splitting into subranges
 * ```ts
 * import { ipv6 } from 'cidr-block';
 *
 * const cidr = ipv6.cidr("2001:db8::/32");
 *
 * // Split into equal /48 subnets
 * cidr.subnet(34).map(s => s.toString());
 * // ["2001:db8::/34", "2001:db8:4000::/34", "2001:db8:8000::/34", "2001:db8:c000::/34"]
 * ```
 *
 * @example Navigating sequential CIDRs
 * ```ts
 * import { ipv6 } from 'cidr-block';
 *
 * const cidr = ipv6.cidr("2001:db8::/32");
 * cidr.nextCIDR()?.toString();     // "2001:db9::/32"
 * cidr.previousCIDR()?.toString(); // "2001:db7::/32"
 * ```
 */
declare class Ipv6Cidr {
    #private;
    constructor(address: Ipv6CidrLiteral);
    /**
     * Gets the base IPv6 address of the CIDR.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const cidr = ipv6.cidr("2001:db8::/32");
     * cidr.baseAddress().toString(); // "2001:db8::"
     * ```
     *
     * @returns The base IPv6 address.
     */
    baseAddress(): Ipv6Address;
    /**
     * Gets the CIDR range.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const cidr = ipv6.cidr("2001:db8::/32");
     * cidr.range(); // 32
     * ```
     *
     * @returns The CIDR range as a number.
     */
    range(): number;
    /**
     * Calculates the netmask for the CIDR range.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * ipv6.cidr("2001:db8::/32").netmask().toString();  // "ffff:ffff::"
     * ipv6.cidr("2001:db8::/64").netmask().toString();  // "ffff:ffff:ffff:ffff::"
     * ipv6.cidr("2001:db8::/128").netmask().toString(); // "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"
     * ```
     *
     * @returns The netmask as an Ipv6Address.
     */
    netmask(): Ipv6Address;
    /**
     * Calculates the hostmask (inverse of the netmask) for the CIDR range.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * ipv6.cidr("2001:db8::/32").hostmask().toString();  // "::ffff:ffff:ffff:ffff:ffff:ffff"
     * ipv6.cidr("2001:db8::/64").hostmask().toString();  // "::ffff:ffff:ffff:ffff"
     * ipv6.cidr("2001:db8::/48").hostmask().toString();  // "::ffff:ffff:ffff:ffff:ffff"
     * ```
     *
     * @returns The hostmask as an Ipv6Address.
     */
    hostmask(): Ipv6Address;
    /**
     * Calculates the network address by applying the netmask to the base address.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * ipv6.cidr("2001:db8::1234/32").network().toString();        // "2001:db8::"
     * ipv6.cidr("2001:db8:1:2:3:4:5:6/64").network().toString();  // "2001:db8:1:2::"
     * ipv6.cidr("2001:db8:abcd::/48").network().toString();       // "2001:db8:abcd::"
     * ```
     *
     * @returns The network address as an Ipv6Address.
     */
    network(): Ipv6Address;
    /**
     * Calculates the network CIDR by applying the netmask to the base address and returning a CIDR with the network address.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * ipv6.cidr("2001:db8::1234/32").networkCIDR().toString();        // "2001:db8::/32"
     * ipv6.cidr("2001:db8:1:2:3:4:5:6/64").networkCIDR().toString();  // "2001:db8:1:2::/64"
     * ipv6.cidr("2001:db8:abcd::/48").networkCIDR().toString();       // "2001:db8:abcd::/48"
     * ```
     *
     * @returns The network CIDR as an Ipv6Cidr.
     */
    networkCIDR(): Ipv6Cidr;
    /**
     * Returns the string representation of the IPv6 CIDR.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const cidr = ipv6.cidr({ address: "2001:db8::", range: 32 });
     * cidr.toString(); // "2001:db8::/32"
     * ```
     *
     * @returns The IPv6 CIDR as a string (example: "2001:db8::/32").
     */
    toString(): string;
    /**
     * Gets the address and range parts of the IPv6 CIDR.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const [address, range] = ipv6.cidr("2001:db8::/32").rangeParts();
     * address.toString(); // "2001:db8::"
     * range; // 32
     * ```
     *
     * @returns A tuple containing the IPv6 address and the CIDR range.
     */
    rangeParts(): [Ipv6Address, number];
    /**
     * Calculates the total number of addresses in the CIDR range.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * ipv6.cidr("2001:db8::/64").addressCount();  // 18446744073709551616n
     * ipv6.cidr("2001:db8::/128").addressCount(); // 1n
     * ipv6.cidr("2001:db8::/126").addressCount(); // 4n
     * ```
     *
     * @returns The total number of addresses in the CIDR range as a BigInt.
     */
    addressCount(): bigint;
    /**
     * Generates IPv6 addresses within the CIDR range.
     * Note: For large CIDR ranges, this may generate an extremely large number of addresses.
     * Use with caution and consider using a limit parameter.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const cidr = ipv6.cidr("2001:db8::/126");
     * for (const addr of cidr.addresses()) {
     *   console.log(addr.toString());
     * }
     * // Output: "2001:db8::", "2001:db8::1", "2001:db8::2", "2001:db8::3"
     * ```
     *
     * @param limit - Optional maximum number of addresses to generate (defaults to all addresses).
     * @returns A generator that yields each IPv6 address in the CIDR range.
     */
    addresses(limit?: bigint): Generator<Ipv6Address>;
    /**
     * Checks if this CIDR is equal to another CIDR.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const cidr = ipv6.cidr("2001:db8::/32");
     * cidr.equals("2001:db8::/32");                      // true
     * cidr.equals({ address: "2001:db8::", range: 32 }); // true
     * cidr.equals("2001:db8::/48");                      // false
     * ```
     *
     * @param other - The other IPv6 CIDR to compare with.
     * @returns True if both CIDRs have the same base address and range; otherwise, false.
     */
    equals(other: Ipv6Cidr | Ipv6CidrLiteral): boolean;
    /**
     * Checks if there is a next sequential CIDR.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * ipv6.cidr("2001:db8::/32").hasNextCIDR(); // true
     * ipv6.cidr("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ff00/120").hasNextCIDR(); // false
     * ```
     *
     * @returns true if there is a next CIDR.
     */
    hasNextCIDR(): boolean;
    /**
     * Gets the next sequential CIDR.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const cidr = ipv6.cidr("2001:db8::/32");
     * cidr.nextCIDR()?.toString(); // "2001:db9::/32"
     * ```
     *
     * @returns The next CIDR, or undefined if there is no next CIDR.
     */
    nextCIDR(): Ipv6Cidr | undefined;
    /**
     * Checks if there is a previous sequential CIDR.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * ipv6.cidr("2001:db8::/32").hasPreviousCIDR(); // true
     * ipv6.cidr("::/32").hasPreviousCIDR();         // false
     * ```
     *
     * @returns true if there is a previous CIDR.
     */
    hasPreviousCIDR(): boolean;
    /**
     * Gets the previous sequential CIDR.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const cidr = ipv6.cidr("2001:db8::/32");
     * cidr.previousCIDR()?.toString(); // "2001:db7::/32"
     *
     * const firstCidr = ipv6.cidr("::/32");
     * firstCidr.previousCIDR(); // undefined
     * ```
     *
     * @returns The previous CIDR, or undefined if there is no previous CIDR.
     */
    previousCIDR(): Ipv6Cidr | undefined;
    /**
     * Gets the first usable address in the CIDR range.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const cidr = ipv6.cidr("2001:db8::/64");
     * cidr.getFirstUsableAddress()?.toString(); // "2001:db8::1"
     *
     * const hostCidr = ipv6.cidr("2001:db8::1/128");
     * hostCidr.getFirstUsableAddress(); // undefined (no usable addresses in /128)
     * ```
     *
     * @returns The first usable IPv6 address, or undefined if the range is /128.
     */
    getFirstUsableAddress(): Ipv6Address | undefined;
    /**
     * Gets the last usable address in the CIDR range.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const cidr = ipv6.cidr("2001:db8::/126");
     * cidr.getLastUsableAddress()?.toString(); // "2001:db8::2"
     *
     * const hostCidr = ipv6.cidr("2001:db8::1/128");
     * hostCidr.getLastUsableAddress(); // undefined (no usable addresses in /128)
     * ```
     *
     * @returns The last usable IPv6 address, or undefined if the range is /128.
     */
    getLastUsableAddress(): Ipv6Address | undefined;
    /**
     * Checks if the given IPv6 address is within the CIDR range.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const cidr = ipv6.cidr("2001:db8::/32");
     * cidr.includes(ipv6.address("2001:db8::1"));  // true
     * cidr.includes(ipv6.address("2001:db9::1"));  // false
     * ```
     *
     * @param ip - The IPv6 address to check.
     * @returns True if the address is within the CIDR range; otherwise, false.
     */
    includes(ip: Ipv6Address): boolean;
    /**
     * Checks if this CIDR overlaps with another CIDR.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const cidr = ipv6.cidr("2001:db8::/32");
     * cidr.overlaps("2001:db8::/48");   // true (subset)
     * cidr.overlaps("2001:db8:8000::/33"); // true (partial overlap)
     * cidr.overlaps("2001:db9::/32");   // false (no overlap)
     * ```
     *
     * @param other - The other IPv6 CIDR to check for overlap.
     * @returns True if the CIDRs overlap; otherwise, false.
     */
    overlaps(other: Ipv6Cidr | Ipv6CidrLiteral): boolean;
    /**
     * Splits the CIDR into smaller subranges of the specified new range.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const cidr = ipv6.cidr("2001:db8::/32");
     * const subnets = cidr.subnet(34);
     * subnets.map(s => s.toString());
     * // ["2001:db8::/34", "2001:db8:4000::/34", "2001:db8:8000::/34", "2001:db8:c000::/34"]
     * ```
     *
     * @param newRange - The new CIDR range for the subnets.
     * @returns An array of Ipv6Cidr instances representing the subnets.
     * @throws InvalidIpv6CidrRangeError if the new range is less than the current range or greater than the maximum range.
     */
    subnet(newRange: number): Ipv6Cidr[];
    /**
     * Splits the CIDR into sequential subranges with the specified CIDR ranges.
     * Each range in the input array creates a subrange starting where the previous one ended.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const cidr = ipv6.cidr("2001:db8::/32");
     * const subnets = cidr.subnetBy([48, 36, 48]);
     * subnets.map(s => s.toString());
     * // ["2001:db8::/48", "2001:db8:1::/36", "2001:db8:1100::/48"]
     * ```
     *
     * @param ranges - An array of CIDR range values (e.g., [48, 36, 48]).
     * @returns An array of Ipv6Cidr instances representing the subnets.
     * @throws InvalidIpv6CidrRangeError if any range is less than the current range or greater than 128.
     */
    subnetBy(ranges: number[]): Ipv6Cidr[];
}

declare class InvalidIpv6AddressError extends Error {
    name: string;
    constructor(invalidAddress: unknown);
}
declare class InvalidIpv6CidrError extends Error {
    name: string;
    constructor(invalidCidr: unknown);
}
declare class InvalidIpv6CidrRangeError extends Error {
    name: string;
}

declare namespace ipv6 {
    /**
     * The maximum possible value for an IPv6 address.
     */
    const MAX_SIZE: bigint;
    /**
     * The minimum possible value for an IPv6 address.
     */
    const MIN_SIZE = 0n;
    /**
     * The maximum CIDR range for IPv6 addresses.
     */
    const MAX_RANGE = 128;
    /**
     * The minimum CIDR range for IPv6 addresses.
     */
    const MIN_RANGE = 0;
    /**
     * Creates a new Ipv6Address instance from the given literal.
     * Valid formats include string (with :: compression support), bigint, or hextets array.
     *
     * @example Creating addresses
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const addr1 = ipv6.address("2001:db8::1");
     * const addr2 = ipv6.address(42540766411282592856903984951653826561n);
     * const addr3 = ipv6.address([0x2001, 0xdb8, 0, 0, 0, 0, 0, 1]);
     * ```
     *
     * @example Converting between formats
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const addr = ipv6.address("2001:db8::1");
     * addr.toString();       // "2001:db8::1" (compressed)
     * addr.toFullString();   // "2001:0db8:0000:0000:0000:0000:0000:0001"
     * addr.toBigInt();       // 42540766411282592856903984951653826561n
     * addr.hextets();        // [0x2001, 0xdb8, 0, 0, 0, 0, 0, 1]
     * ```
     *
     * @example Comparing addresses
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const addr = ipv6.address("2001:db8::1");
     * addr.equals("2001:db8::1");      // true
     * addr.isGreaterThan("2001:db8::"); // true
     * addr.isLessThan("2001:db8::2");    // true
     * ```
     *
     * @example Navigating sequential addresses
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const addr = ipv6.address("2001:db8::1");
     * addr.nextAddress()?.toString();     // "2001:db8::2"
     * addr.previousAddress()?.toString(); // "2001:db8::"
     * ```
     *
     * @example Checking address types
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * ipv6.address("::1").isLoopbackAddress();         // true
     * ipv6.address("fc00::1").isUniqueLocalAddress();  // true
     * ipv6.address("fe80::1").isLinkLocalAddress();    // true
     * ipv6.address("ff02::1").isMulticastAddress();    // true
     * ```
     *
     * @param ip - The IPv6 address in string, bigint, or hextets array format.
     * @returns A new Ipv6Address instance.
     * @throws {InvalidIpv6AddressError} If the input is not a valid IPv6 address.
     */
    function address(ip: Ipv6AddressLiteral): Ipv6Address;
    /**
     * Creates a new Ipv6Cidr instance from the given literal.
     * Valid formats include string, object, or tuple.
     *
     * @example Creating CIDR blocks
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const cidr1 = ipv6.cidr("2001:db8::/32");
     * const cidr2 = ipv6.cidr({ address: "2001:db8::", range: 32 });
     * const cidr3 = ipv6.cidr(["2001:db8::", 32]);
     * ```
     *
     * @example Getting CIDR properties
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const cidr = ipv6.cidr("2001:db8::/32");
     * cidr.baseAddress().toString(); // "2001:db8::"
     * cidr.range();                  // 32
     * cidr.netmask().toString();     // "ffff:ffff::"
     * cidr.addressCount();           // 79228162514264337593543950336n
     * ```
     *
     * @example Working with usable addresses
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const cidr = ipv6.cidr("2001:db8::/126");
     * cidr.getFirstUsableAddress()?.toString(); // "2001:db8::1"
     * cidr.getLastUsableAddress()?.toString();  // "2001:db8::2"
     * ```
     *
     * @example Checking containment and overlap
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const cidr = ipv6.cidr("2001:db8::/32");
     * cidr.includes(ipv6.address("2001:db8::1")); // true
     * cidr.includes(ipv6.address("2001:db9::1")); // false
     * cidr.overlaps("2001:db8::/48");             // true
     * cidr.overlaps("2001:db9::/32");             // false
     * ```
     *
     * @example Splitting into subranges
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const cidr = ipv6.cidr("2001:db8::/32");
     *
     * // Split into equal /34 subnets
     * cidr.subnet(34).map(s => s.toString());
     * // ["2001:db8::/34", "2001:db8:4000::/34", "2001:db8:8000::/34", "2001:db8:c000::/34"]
     * ```
     *
     * @example Navigating sequential CIDRs
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * const cidr = ipv6.cidr("2001:db8::/32");
     * cidr.nextCIDR()?.toString();     // "2001:db9::/32"
     * cidr.previousCIDR()?.toString(); // "2001:db7::/32"
     * ```
     *
     * @param cidr - The IPv6 CIDR in string, object, or tuple format.
     * @returns A new Ipv6Cidr instance.
     * @throws {InvalidIpv6CidrError} If the input is not a valid IPv6 CIDR.
     */
    function cidr(cidr: Ipv6CidrLiteral): Ipv6Cidr;
    /**
     * Validates whether the given input is a valid IPv6 address.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * ipv6.isValidAddress("2001:db8::1");          // true
     * ipv6.isValidAddress("::");                   // true
     * ipv6.isValidAddress("::1");                  // true
     * ipv6.isValidAddress("gggg::1");              // false (invalid hex)
     * ipv6.isValidAddress("2001:db8");             // false (incomplete)
     * ipv6.isValidAddress([0x2001, 0xdb8, 0, 0, 0, 0, 0, 1]); // true
     * ```
     *
     * @param ip - The IPv6 address to validate, which can be in string, bigint, or hextets array format.
     * @returns True if the input is a valid IPv6 address; otherwise, false.
     */
    function isValidAddress(ip: Ipv6AddressLiteral): boolean;
    /**
     * Validates whether the given input is a valid IPv6 CIDR.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * ipv6.isValidCIDR("2001:db8::/32");                   // true
     * ipv6.isValidCIDR("2001:db8::/129");                  // false (range out of bounds)
     * ipv6.isValidCIDR({ address: "2001:db8::", range: 32 }); // true
     * ipv6.isValidCIDR(["2001:db8::", 32]);                // true
     * ipv6.isValidCIDR("invalid/32");                      // false
     * ```
     *
     * @param cidr - The IPv6 CIDR to validate, which can be in string, object, or tuple format.
     * @returns True if the input is a valid IPv6 CIDR; otherwise, false.
     */
    function isValidCIDR(cidr: Ipv6CidrLiteral): boolean;
    /**
     * Parses the given IPv6 address into its hextets representation.
     *
     * @example
     * ```ts
     * import { ipv6 } from 'cidr-block';
     *
     * ipv6.parseHextets("2001:db8::1");   // [0x2001, 0xdb8, 0, 0, 0, 0, 0, 1]
     * ipv6.parseHextets("::");            // [0, 0, 0, 0, 0, 0, 0, 0]
     * ipv6.parseHextets(42540766411282592856903984951653826561n); // [0x2001, 0xdb8, 0, 0, 0, 0, 0, 1]
     * ```
     *
     * @param ip - The IPv6 address to parse, which can be in string, bigint, or hextets array format.
     * @returns {Ipv6AddressHextets} An array of eight numbers representing the hextets of the IPv6 address.
     * @throws {InvalidIpv6AddressError} If the input is not a valid IPv6 address.
     */
    function parseHextets(ip: Ipv6AddressLiteral): Ipv6AddressHextets;
}

export { InvalidIpv4AddressError, InvalidIpv4CidrError, InvalidIpv4CidrRangeError, InvalidIpv6AddressError, InvalidIpv6CidrError, InvalidIpv6CidrRangeError, Ipv4Address, Ipv4Cidr, Ipv6Address, Ipv6Cidr, ipv4, ipv6 };
export type { Ipv4AddressLiteral, Ipv4AddressOctets, Ipv4AddressString, Ipv4CidrLiteral, Ipv4CidrString, Ipv6AddressHextets, Ipv6AddressLiteral, Ipv6CidrLiteral };