{
  "classes": [
    {
      "constants": [],
      "types": [],
      "name": "@eryx/ip",
      "tags": [],
      "functions": [
        {
          "source": {
            "path": "",
            "line": 1412
          },
          "is_method": false,
          "signature": "ip.parse(\n    source: string,  -- Source text to parse, validate, or classify.\n    options: ParseOptions?  -- Optional parse behavior flags (for example `strict`).\n) → (\n      -- Parsed address/network object when the input is valid. \n)",
          "owner": "ip",
          "desc": "Parse an address or network string into the corresponding IP object.",
          "tags": [],
          "name": "parse",
          "return_str": "(IPv4Address | IPv6Address | IPv4Network | IPv6Network)?",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "(IPv4Address | IPv6Address | IPv4Network | IPv6Network)?",
              "desc": "Parsed address/network object when the input is valid. "
            }
          ],
          "params": [
            {
              "lua_type": "string",
              "name": "source",
              "desc": "Source text to parse, validate, or classify."
            },
            {
              "lua_type": "ParseOptions?",
              "name": "options",
              "desc": "Optional parse behavior flags (for example `strict`)."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 1424
          },
          "is_method": false,
          "signature": "ip.address(\n    source: string,  -- Source text to parse, validate, or classify.\n    options: ParseOptions?  -- Optional parse behavior flags (for example `allowZoneId`).\n) → (\n      -- Parsed IPv4 or IPv6 address object when valid. \n)",
          "owner": "ip",
          "desc": "Parse a string into an IPv4Address or IPv6Address.",
          "tags": [],
          "name": "address",
          "return_str": "(IPv4Address | IPv6Address)?",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "(IPv4Address | IPv6Address)?",
              "desc": "Parsed IPv4 or IPv6 address object when valid. "
            }
          ],
          "params": [
            {
              "lua_type": "string",
              "name": "source",
              "desc": "Source text to parse, validate, or classify."
            },
            {
              "lua_type": "ParseOptions?",
              "name": "options",
              "desc": "Optional parse behavior flags (for example `allowZoneId`)."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 1433
          },
          "is_method": false,
          "signature": "ip.network(\n    source: string,  -- Source text to parse, validate, or classify.\n    options: ParseOptions?  -- Optional parse behavior flags (for example `strict` host-bit checks).\n) → (\n      -- Parsed IPv4 or IPv6 network object when valid. \n)",
          "owner": "ip",
          "desc": "Parse a string into an IPv4Network or IPv6Network.",
          "tags": [],
          "name": "network",
          "return_str": "(IPv4Network | IPv6Network)?",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "(IPv4Network | IPv6Network)?",
              "desc": "Parsed IPv4 or IPv6 network object when valid. "
            }
          ],
          "params": [
            {
              "lua_type": "string",
              "name": "source",
              "desc": "Source text to parse, validate, or classify."
            },
            {
              "lua_type": "ParseOptions?",
              "name": "options",
              "desc": "Optional parse behavior flags (for example `strict` host-bit checks)."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 1442
          },
          "is_method": false,
          "signature": "ip.interface(\n    source: string,  -- Source text to parse, validate, or classify.\n    options: ParseOptions?  -- Optional parse behavior flags forwarded to address parsing.\n) → (\n      -- Parsed IPv4 or IPv6 interface object when valid. \n)",
          "owner": "ip",
          "desc": "Parse a string into an IPv4Interface or IPv6Interface.",
          "tags": [],
          "name": "interface",
          "return_str": "(IPv4Interface | IPv6Interface)?",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "(IPv4Interface | IPv6Interface)?",
              "desc": "Parsed IPv4 or IPv6 interface object when valid. "
            }
          ],
          "params": [
            {
              "lua_type": "string",
              "name": "source",
              "desc": "Source text to parse, validate, or classify."
            },
            {
              "lua_type": "ParseOptions?",
              "name": "options",
              "desc": "Optional parse behavior flags forwarded to address parsing."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 1451
          },
          "is_method": false,
          "signature": "ip.isAddress(\n    source: string  -- Source text to parse, validate, or classify.\n) → (\n      -- True when the input is recognized as a valid address. \n)",
          "owner": "ip",
          "desc": "Return true when the input is a valid IP address string.",
          "tags": [],
          "name": "isAddress",
          "return_str": "boolean",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "True when the input is recognized as a valid address. "
            }
          ],
          "params": [
            {
              "lua_type": "string",
              "name": "source",
              "desc": "Source text to parse, validate, or classify."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 1459
          },
          "is_method": false,
          "signature": "ip.isNetwork(\n    source: string  -- Source text to parse, validate, or classify.\n) → (\n      -- True when the input is recognized as a valid network. \n)",
          "owner": "ip",
          "desc": "Return true when the input is a valid CIDR/network string.",
          "tags": [],
          "name": "isNetwork",
          "return_str": "boolean",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "True when the input is recognized as a valid network. "
            }
          ],
          "params": [
            {
              "lua_type": "string",
              "name": "source",
              "desc": "Source text to parse, validate, or classify."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 1467
          },
          "is_method": false,
          "signature": "ip.isIPv4(\n    source: string  -- Source text to parse, validate, or classify.\n) → (\n      -- True when input resolves to an IPv4 address or network. \n)",
          "owner": "ip",
          "desc": "Return true when the input parses as an IPv4 address or network.",
          "tags": [],
          "name": "isIPv4",
          "return_str": "boolean",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "True when input resolves to an IPv4 address or network. "
            }
          ],
          "params": [
            {
              "lua_type": "string",
              "name": "source",
              "desc": "Source text to parse, validate, or classify."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 1484
          },
          "is_method": false,
          "signature": "ip.isIPv6(\n    source: string  -- Source text to parse, validate, or classify.\n) → (\n      -- True when input resolves to an IPv6 address or network. \n)",
          "owner": "ip",
          "desc": "Return true when the input parses as an IPv6 address or network.",
          "tags": [],
          "name": "isIPv6",
          "return_str": "boolean",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "True when input resolves to an IPv6 address or network. "
            }
          ],
          "params": [
            {
              "lua_type": "string",
              "name": "source",
              "desc": "Source text to parse, validate, or classify."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 1503
          },
          "is_method": false,
          "signature": "ip.smallestEnclosingIPv4Network(\n    a: IPv4Address,  -- Primary input value or left operand.\n    b: IPv4Address  -- Secondary input value or right operand.\n) → (\n      -- Smallest IPv4 CIDR block containing both inputs. \n)",
          "owner": "ip",
          "desc": "Return the smallest IPv4 network containing both IPv4 addresses.",
          "tags": [],
          "name": "smallestEnclosingIPv4Network",
          "return_str": "IPv4Network",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "IPv4Network",
              "desc": "Smallest IPv4 CIDR block containing both inputs. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv4Address",
              "name": "a",
              "desc": "Primary input value or left operand."
            },
            {
              "lua_type": "IPv4Address",
              "name": "b",
              "desc": "Secondary input value or right operand."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 1513
          },
          "is_method": false,
          "signature": "ip.smallestEnclosingIPv6Network(\n    a: IPv6Address,  -- Primary input value or left operand.\n    b: IPv6Address  -- Secondary input value or right operand.\n) → (\n      -- Smallest IPv6 CIDR block containing both inputs. \n)",
          "owner": "ip",
          "desc": "Return the smallest IPv6 network containing both IPv6 addresses.",
          "tags": [],
          "name": "smallestEnclosingIPv6Network",
          "return_str": "IPv6Network",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "IPv6Network",
              "desc": "Smallest IPv6 CIDR block containing both inputs. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv6Address",
              "name": "a",
              "desc": "Primary input value or left operand."
            },
            {
              "lua_type": "IPv6Address",
              "name": "b",
              "desc": "Secondary input value or right operand."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 1550
          },
          "is_method": false,
          "signature": "ip.sortIPv4(\n    values: { IPv4Address | string }  -- Collection of address values to parse/coerce and sort.\n) → (\n      -- IPv4 address list sorted in ascending numeric order. \n)",
          "owner": "ip",
          "desc": "Parse/coerce and sort a list of IPv4 addresses in ascending order.",
          "tags": [],
          "name": "sortIPv4",
          "return_str": "{ IPv4Address }",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "{ IPv4Address }",
              "desc": "IPv4 address list sorted in ascending numeric order. "
            }
          ],
          "params": [
            {
              "lua_type": "{ IPv4Address | string }",
              "name": "values",
              "desc": "Collection of address values to parse/coerce and sort."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 1559
          },
          "is_method": false,
          "signature": "ip.sortIPv6(\n    values: { IPv6Address | string }  -- Collection of address values to parse/coerce and sort.\n) → (\n      -- IPv6 address list sorted in ascending lexical order. \n)",
          "owner": "ip",
          "desc": "Parse/coerce and sort a list of IPv6 addresses in ascending order.",
          "tags": [],
          "name": "sortIPv6",
          "return_str": "{ IPv6Address }",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "{ IPv6Address }",
              "desc": "IPv6 address list sorted in ascending lexical order. "
            }
          ],
          "params": [
            {
              "lua_type": "{ IPv6Address | string }",
              "name": "values",
              "desc": "Collection of address values to parse/coerce and sort."
            }
          ]
        }
      ],
      "properties": [],
      "source": {
        "path": "",
        "line": 0
      },
      "desc": ""
    },
    {
      "is_primary_export": false,
      "source": {
        "path": "",
        "line": 9
      },
      "tags": [],
      "properties": [
        {
          "tags": [],
          "lua_type": "version: number",
          "name": "version",
          "desc": "IP version number (`4`)."
        },
        {
          "tags": [],
          "lua_type": "_octets: { number }",
          "name": "_octets",
          "desc": "IPv4 octets in network order."
        },
        {
          "tags": [],
          "lua_type": "_int: number",
          "name": "_int",
          "desc": "Packed 32-bit integer representation."
        }
      ],
      "desc": "Represents an IPv4 address.",
      "name": "IPv4Address",
      "functions": [
        {
          "source": {
            "path": "",
            "line": 1568
          },
          "is_method": false,
          "signature": "IPv4Address.sort(\n    values: { IPv4Address | string }  -- IPv4Address instances or parseable IPv4 strings.\n) → (\n      -- Parsed and sorted IPv4 addresses. \n)",
          "owner": "IPv4Address",
          "desc": "Sort a collection of IPv4 address values.",
          "tags": [],
          "name": "sort",
          "return_str": "{ IPv4Address }",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "{ IPv4Address }",
              "desc": "Parsed and sorted IPv4 addresses. "
            }
          ],
          "params": [
            {
              "lua_type": "{ IPv4Address | string }",
              "name": "values",
              "desc": "IPv4Address instances or parseable IPv4 strings."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 1619
          },
          "is_method": false,
          "signature": "IPv4Address.parse(\n    source: string,  -- IPv4 address text to parse.\n    options: ParseOptions?  -- Optional parse behavior flags.\n) → (\n      -- Parsed IPv4Address when the input is valid. \n)",
          "owner": "IPv4Address",
          "desc": "Parse an IPv4 address string with optional parse options.",
          "tags": [],
          "name": "parse",
          "return_str": "IPv4Address?",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "IPv4Address?",
              "desc": "Parsed IPv4Address when the input is valid. "
            }
          ],
          "params": [
            {
              "lua_type": "string",
              "name": "source",
              "desc": "IPv4 address text to parse."
            },
            {
              "lua_type": "ParseOptions?",
              "name": "options",
              "desc": "Optional parse behavior flags."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 2490
          },
          "is_method": false,
          "signature": "IPv4Address.fromOctets(octets: { number }) → IPv4Address",
          "owner": "IPv4Address",
          "desc": "IPv4 Constructors",
          "tags": [],
          "name": "fromOctets",
          "return_str": "IPv4Address",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "IPv4Address",
              "desc": ""
            }
          ],
          "params": [
            {
              "lua_type": "{ number }",
              "name": "octets",
              "desc": ""
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 2507
          },
          "is_method": false,
          "signature": "IPv4Address.fromInteger(\n    val: number  -- Raw integer or packed bytes used to construct an address.\n) → (\n      -- IPv4Address built from the packed integer. \n)",
          "owner": "IPv4Address",
          "desc": "Create an IPv4Address from a 32-bit integer.",
          "tags": [],
          "name": "fromInteger",
          "return_str": "IPv4Address",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "IPv4Address",
              "desc": "IPv4Address built from the packed integer. "
            }
          ],
          "params": [
            {
              "lua_type": "number",
              "name": "val",
              "desc": "Raw integer or packed bytes used to construct an address."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 2518
          },
          "is_method": false,
          "signature": "IPv4Address.fromBytes(\n    val: buffer | { number }  -- Raw integer or packed bytes used to construct an address.\n) → (\n      -- IPv4Address built from 4-byte input. \n)",
          "owner": "IPv4Address",
          "desc": "Create an IPv4Address from a 4-byte buffer or byte array.",
          "tags": [],
          "name": "fromBytes",
          "return_str": "IPv4Address",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "IPv4Address",
              "desc": "IPv4Address built from 4-byte input. "
            }
          ],
          "params": [
            {
              "lua_type": "buffer | { number }",
              "name": "val",
              "desc": "Raw integer or packed bytes used to construct an address."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 2544
          },
          "is_method": false,
          "signature": "IPv4Address.fromPacked(\n    val: buffer | { number }  -- Buffer or byte array containing exactly four bytes.\n) → (\n      -- Parsed IPv4Address from packed input. \n)",
          "owner": "IPv4Address",
          "desc": "Create an IPv4Address from packed byte input.",
          "tags": [],
          "name": "fromPacked",
          "return_str": "IPv4Address",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "IPv4Address",
              "desc": "Parsed IPv4Address from packed input. "
            }
          ],
          "params": [
            {
              "lua_type": "buffer | { number }",
              "name": "val",
              "desc": "Buffer or byte array containing exactly four bytes."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 2549
          },
          "is_method": true,
          "signature": "IPv4Address:__string() → string",
          "owner": "IPv4Address",
          "desc": "Return a canonical IPv4 string",
          "tags": [],
          "name": "__string",
          "return_str": "string",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "string",
              "desc": ""
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2553
          },
          "is_method": true,
          "signature": "IPv4Address:reverseUri() → string",
          "owner": "IPv4Address",
          "desc": "Return the PTR/arpa form of the IP",
          "tags": [],
          "name": "reverseUri",
          "return_str": "string",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "string",
              "desc": ""
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2564
          },
          "is_method": true,
          "signature": "IPv4Address:toInteger() → number",
          "owner": "IPv4Address",
          "desc": "Pack the four octets into a 32 bit integer",
          "tags": [],
          "name": "toInteger",
          "return_str": "number",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "number",
              "desc": ""
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2568
          },
          "is_method": true,
          "signature": "IPv4Address:toBytes() → buffer",
          "owner": "IPv4Address",
          "desc": "Pack the four octets into four bytes in a buffer",
          "tags": [],
          "name": "toBytes",
          "return_str": "buffer",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "buffer",
              "desc": ""
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2582
          },
          "is_method": true,
          "signature": "IPv4Address:toPacked() → (\n      -- containing four network-order bytes. \n)",
          "owner": "IPv4Address",
          "desc": "Return packed IPv4 bytes for this address.\n@param self Current IPv4Address instance.",
          "tags": [],
          "name": "toPacked",
          "return_str": "buffer",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "buffer",
              "desc": "containing four network-order bytes. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2591
          },
          "is_method": true,
          "signature": "IPv4Address:isPrivate() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv4Address",
          "desc": "Return true for RFC1918 private IPv4 ranges.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isPrivate",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2600
          },
          "is_method": true,
          "signature": "IPv4Address:ipPublic() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv4Address",
          "desc": "Return true when the IPv4 address is globally reachable.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "ipPublic",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2608
          },
          "is_method": true,
          "signature": "IPv4Address:isLoopback() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv4Address",
          "desc": "Return true for 127.0.0.0/8 loopback addresses.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isLoopback",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2616
          },
          "is_method": true,
          "signature": "IPv4Address:isMulticast() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv4Address",
          "desc": "Return true for 224.0.0.0/4 multicast addresses.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isMulticast",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2625
          },
          "is_method": true,
          "signature": "IPv4Address:isLinkLocal() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv4Address",
          "desc": "Return true for 169.254.0.0/16 link-local addresses.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isLinkLocal",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2634
          },
          "is_method": true,
          "signature": "IPv4Address:isUnspecified() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv4Address",
          "desc": "Return true for 0.0.0.0.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isUnspecified",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2642
          },
          "is_method": true,
          "signature": "IPv4Address:isReserved() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv4Address",
          "desc": "Return true for reserved Class E IPv4 addresses.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isReserved",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2652
          },
          "is_method": true,
          "signature": "IPv4Address:isDocumentation() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv4Address",
          "desc": "Return true for TEST-NET documentation ranges.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isDocumentation",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2663
          },
          "is_method": true,
          "signature": "IPv4Address:isBenchmarking() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv4Address",
          "desc": "Return true for IPv4 benchmarking ranges.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isBenchmarking",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2672
          },
          "is_method": true,
          "signature": "IPv4Address:isShared() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv4Address",
          "desc": "Return true for shared CGNAT space (100.64.0.0/10).\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isShared",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2681
          },
          "is_method": true,
          "signature": "IPv4Address:isGlobal() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv4Address",
          "desc": "Return true when IPv4 address is considered globally reachable.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isGlobal",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2699
          },
          "is_method": true,
          "signature": "IPv4Address:category() → (\n      -- representation or textual result. \n)",
          "owner": "IPv4Address",
          "desc": "TODO: Replace string with a union of all categories (loopback, multicast, LL, reserved, etc)\n\nReturn a coarse category label describing this IPv4 address.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "category",
          "return_str": "string",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "string",
              "desc": "representation or textual result. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2731
          },
          "is_method": true,
          "signature": "IPv4Address:isBroadcast() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv4Address",
          "desc": "Return true for 255.255.255.255.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isBroadcast",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2741
          },
          "is_method": true,
          "signature": "IPv4Address:inNetwork(\n    net: IPv4Network  -- Network to test membership, overlap, or containment against.\n) → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv4Address",
          "desc": "Return true if this IPv4 address is inside the given network.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "inNetwork",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv4Network",
              "name": "net",
              "desc": "Network to test membership, overlap, or containment against."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 2751
          },
          "is_method": true,
          "signature": "IPv4Address:next() → (\n      -- Next IPv4 address value. \n)",
          "owner": "IPv4Address",
          "desc": "Return the next IPv4 address.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "next",
          "return_str": "IPv4Address",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv4Address",
              "desc": "Next IPv4 address value. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2763
          },
          "is_method": true,
          "signature": "IPv4Address:previous() → (\n      -- Previous IPv4 address value. \n)",
          "owner": "IPv4Address",
          "desc": "Return the previous IPv4 address.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "previous",
          "return_str": "IPv4Address",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv4Address",
              "desc": "Previous IPv4 address value. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2776
          },
          "is_method": true,
          "signature": "IPv4Address:toIPv6Mapped() → (\n      -- IPv4-mapped IPv6 equivalent of this address. \n)",
          "owner": "IPv4Address",
          "desc": "Return the IPv4-mapped IPv6 form of this IPv4 address.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "toIPv6Mapped",
          "return_str": "IPv6Address",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv6Address",
              "desc": "IPv4-mapped IPv6 equivalent of this address. "
            }
          ],
          "params": []
        }
      ],
      "metamethods": [],
      "types": []
    },
    {
      "is_primary_export": false,
      "source": {
        "path": "",
        "line": 27
      },
      "tags": [],
      "properties": [
        {
          "tags": [],
          "lua_type": "version: number",
          "name": "version",
          "desc": "IP version number (`6`)."
        },
        {
          "tags": [],
          "lua_type": "_hextets: { number }",
          "name": "_hextets",
          "desc": "IPv6 hextets in network order."
        }
      ],
      "desc": "Represents an IPv6 address.",
      "name": "IPv6Address",
      "functions": [
        {
          "source": {
            "path": "",
            "line": 1593
          },
          "is_method": false,
          "signature": "IPv6Address.sort(\n    values: { IPv6Address | string }  -- IPv6Address instances or parseable IPv6 strings.\n) → (\n      -- Parsed and sorted IPv6 addresses. \n)",
          "owner": "IPv6Address",
          "desc": "Sort a collection of IPv6 address values.",
          "tags": [],
          "name": "sort",
          "return_str": "{ IPv6Address }",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "{ IPv6Address }",
              "desc": "Parsed and sorted IPv6 addresses. "
            }
          ],
          "params": [
            {
              "lua_type": "{ IPv6Address | string }",
              "name": "values",
              "desc": "IPv6Address instances or parseable IPv6 strings."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 1633
          },
          "is_method": false,
          "signature": "IPv6Address.parse(\n    source: string,  -- IPv6 address text to parse.\n    options: ParseOptions?  -- Optional parse behavior flags.\n) → (\n      -- Parsed IPv6Address when the input is valid. \n)",
          "owner": "IPv6Address",
          "desc": "Parse an IPv6 address string with optional parse options.",
          "tags": [],
          "name": "parse",
          "return_str": "IPv6Address?",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "IPv6Address?",
              "desc": "Parsed IPv6Address when the input is valid. "
            }
          ],
          "params": [
            {
              "lua_type": "string",
              "name": "source",
              "desc": "IPv6 address text to parse."
            },
            {
              "lua_type": "ParseOptions?",
              "name": "options",
              "desc": "Optional parse behavior flags."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 2793
          },
          "is_method": false,
          "signature": "IPv6Address.fromBytes(val: buffer | { number }) → IPv6Address",
          "owner": "IPv6Address",
          "desc": "IPv6 Constructors",
          "tags": [],
          "name": "fromBytes",
          "return_str": "IPv6Address",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "IPv6Address",
              "desc": ""
            }
          ],
          "params": [
            {
              "lua_type": "buffer | { number }",
              "name": "val",
              "desc": ""
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 2817
          },
          "is_method": false,
          "signature": "IPv6Address.fromPacked(\n    val: buffer | { number }  -- Buffer or byte array containing exactly sixteen bytes.\n) → (\n      -- Parsed IPv6Address from packed input. \n)",
          "owner": "IPv6Address",
          "desc": "Create an IPv6Address from packed byte input.",
          "tags": [],
          "name": "fromPacked",
          "return_str": "IPv6Address",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "IPv6Address",
              "desc": "Parsed IPv6Address from packed input. "
            }
          ],
          "params": [
            {
              "lua_type": "buffer | { number }",
              "name": "val",
              "desc": "Buffer or byte array containing exactly sixteen bytes."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 2826
          },
          "is_method": false,
          "signature": "IPv6Address.fromInteger(\n    val: number | string  -- Number or decimal string representation of a 128-bit integer.\n) → (\n      -- Parsed IPv6Address from integer input. \n)",
          "owner": "IPv6Address",
          "desc": "Create an IPv6Address from a non-negative integer value.",
          "tags": [],
          "name": "fromInteger",
          "return_str": "IPv6Address",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "IPv6Address",
              "desc": "Parsed IPv6Address from integer input. "
            }
          ],
          "params": [
            {
              "lua_type": "number | string",
              "name": "val",
              "desc": "Number or decimal string representation of a 128-bit integer."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 2842
          },
          "is_method": true,
          "signature": "IPv6Address:__string() → string",
          "owner": "IPv6Address",
          "desc": "Return a canonical IPv6 string (compressed)",
          "tags": [],
          "name": "__string",
          "return_str": "string",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "string",
              "desc": ""
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2846
          },
          "is_method": true,
          "signature": "IPv6Address:compressed() → string",
          "owner": "IPv6Address",
          "desc": "Return the fully compressed IPv6",
          "tags": [],
          "name": "compressed",
          "return_str": "string",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "string",
              "desc": ""
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2850
          },
          "is_method": true,
          "signature": "IPv6Address:expanded() → string",
          "owner": "IPv6Address",
          "desc": "Return the fully expanded IPv6",
          "tags": [],
          "name": "expanded",
          "return_str": "string",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "string",
              "desc": ""
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2854
          },
          "is_method": true,
          "signature": "IPv6Address:toUriHost() → string",
          "owner": "IPv6Address",
          "desc": "Return `[compressed]`",
          "tags": [],
          "name": "toUriHost",
          "return_str": "string",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "string",
              "desc": ""
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2858
          },
          "is_method": true,
          "signature": "IPv6Address:reverseUri() → string",
          "owner": "IPv6Address",
          "desc": "Return the PTR/arpa form of the IP",
          "tags": [],
          "name": "reverseUri",
          "return_str": "string",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "string",
              "desc": ""
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2872
          },
          "is_method": true,
          "signature": "IPv6Address:toBytes() → buffer",
          "owner": "IPv6Address",
          "desc": "Pack the bytes into a buffer",
          "tags": [],
          "name": "toBytes",
          "return_str": "buffer",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "buffer",
              "desc": ""
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2886
          },
          "is_method": true,
          "signature": "IPv6Address:toPacked() → (\n      -- containing sixteen network-order bytes. \n)",
          "owner": "IPv6Address",
          "desc": "Return packed IPv6 bytes for this address.\n@param self Current IPv6Address instance.",
          "tags": [],
          "name": "toPacked",
          "return_str": "buffer",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "buffer",
              "desc": "containing sixteen network-order bytes. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2895
          },
          "is_method": true,
          "signature": "IPv6Address:toInteger() → (\n      -- Decimal string representing the 128-bit address value. \n)",
          "owner": "IPv6Address",
          "desc": "Return the integer representation of this IPv6 address.\n@param self Current IPv6Address instance.",
          "tags": [],
          "name": "toInteger",
          "return_str": "string",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "string",
              "desc": "Decimal string representing the 128-bit address value. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2904
          },
          "is_method": true,
          "signature": "IPv6Address:isPrivate() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv6Address",
          "desc": "Return true for private (unique local) IPv6 addresses.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isPrivate",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2912
          },
          "is_method": true,
          "signature": "IPv6Address:ipPublic() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv6Address",
          "desc": "Return true when the IPv6 address is globally reachable.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "ipPublic",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2920
          },
          "is_method": true,
          "signature": "IPv6Address:isLoopback() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv6Address",
          "desc": "Return true for ::1.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isLoopback",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2934
          },
          "is_method": true,
          "signature": "IPv6Address:isMulticast() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv6Address",
          "desc": "Return true for ff00::/8 multicast addresses.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isMulticast",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2942
          },
          "is_method": true,
          "signature": "IPv6Address:isLinkLocal() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv6Address",
          "desc": "Return true for fe80::/10 link-local addresses.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isLinkLocal",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2951
          },
          "is_method": true,
          "signature": "IPv6Address:isUnspecified() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv6Address",
          "desc": "Return true for ::.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isUnspecified",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2965
          },
          "is_method": true,
          "signature": "IPv6Address:isReserved() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv6Address",
          "desc": "Return true for reserved IPv6 blocks (placeholder).\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isReserved",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2973
          },
          "is_method": true,
          "signature": "IPv6Address:isDocumentation() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv6Address",
          "desc": "Return true for 2001:db8::/32 documentation space.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isDocumentation",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2982
          },
          "is_method": true,
          "signature": "IPv6Address:isBenchmarking() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv6Address",
          "desc": "Return true for IPv6 benchmarking space.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isBenchmarking",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2991
          },
          "is_method": true,
          "signature": "IPv6Address:isShared() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv6Address",
          "desc": "Return true for shared IPv6 ranges (placeholder).\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isShared",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2999
          },
          "is_method": true,
          "signature": "IPv6Address:isGlobal() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv6Address",
          "desc": "Return true when IPv6 address is considered globally reachable.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isGlobal",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3014
          },
          "is_method": true,
          "signature": "IPv6Address:category() → (\n      -- representation or textual result. \n)",
          "owner": "IPv6Address",
          "desc": "TODO: Replace string with a union of all categories (loopback, multicast, LL, reserved, etc)\n\nReturn a coarse category label describing this IPv6 address.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "category",
          "return_str": "string",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "string",
              "desc": "representation or textual result. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3040
          },
          "is_method": true,
          "signature": "IPv6Address:isUniqueLocal() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv6Address",
          "desc": "Return true for fc00::/7 unique local addresses.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isUniqueLocal",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3049
          },
          "is_method": true,
          "signature": "IPv6Address:isIPv4Mapped() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv6Address",
          "desc": "Return true if this is an IPv4-mapped IPv6 address.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isIPv4Mapped",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3058
          },
          "is_method": true,
          "signature": "IPv6Address:isIPv4Compatible() → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv6Address",
          "desc": "Return true if this is an IPv4-compatible IPv6 address.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isIPv4Compatible",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3068
          },
          "is_method": true,
          "signature": "IPv6Address:scope() → (\n      -- \"link-local\" | \"global\" Derived scope classification for this IPv6 address. \n)",
          "owner": "IPv6Address",
          "desc": "TODO: Expand return enum\n\nReturn a coarse IPv6 scope classification.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "scope",
          "return_str": "\"interface-local\" | \"link-local\" | \"global\"",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "\"interface-local\" | \"link-local\" | \"global\"",
              "desc": "\"link-local\" | \"global\" Derived scope classification for this IPv6 address. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3083
          },
          "is_method": true,
          "signature": "IPv6Address:getEmbeddedIPv4() → (\n      -- Embedded IPv4 address when present, otherwise nil. \n)",
          "owner": "IPv6Address",
          "desc": "Extract embedded IPv4 address from mapped/compatible IPv6 forms.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "getEmbeddedIPv4",
          "return_str": "IPv4Address?",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv4Address?",
              "desc": "Embedded IPv4 address when present, otherwise nil. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3102
          },
          "is_method": true,
          "signature": "IPv6Address:toIPv4() → (\n      -- Extracted IPv4Address when conversion is possible. \n)",
          "owner": "IPv6Address",
          "desc": "Convert mapped/compatible IPv6 addresses back to IPv4.\n@param self Current IPv6Address instance.",
          "tags": [],
          "name": "toIPv4",
          "return_str": "IPv4Address?",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv4Address?",
              "desc": "Extracted IPv4Address when conversion is possible. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3111
          },
          "is_method": true,
          "signature": "IPv6Address:is6to4() → (\n      -- True when the address belongs to 6to4 space. \n)",
          "owner": "IPv6Address",
          "desc": "Return true for 6to4 IPv6 addresses (`2002::/16`).\n@param self Current IPv6Address instance.",
          "tags": [],
          "name": "is6to4",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "True when the address belongs to 6to4 space. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3121
          },
          "is_method": true,
          "signature": "IPv6Address:isTeredo() → (\n      -- True when the address belongs to Teredo space. \n)",
          "owner": "IPv6Address",
          "desc": "Return true for Teredo IPv6 addresses (`2001:0000::/32`).\n@param self Current IPv6Address instance.",
          "tags": [],
          "name": "isTeredo",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "True when the address belongs to Teredo space. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3132
          },
          "is_method": true,
          "signature": "IPv6Address:inNetwork(\n    net: IPv6Network  -- Network to test membership, overlap, or containment against.\n) → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv6Address",
          "desc": "Return true if this IPv6 address is inside the given network.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "inNetwork",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv6Network",
              "name": "net",
              "desc": "Network to test membership, overlap, or containment against."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 3142
          },
          "is_method": true,
          "signature": "IPv6Address:next() → (\n      -- Next IPv6 address value. \n)",
          "owner": "IPv6Address",
          "desc": "Return the next IPv6 address.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "next",
          "return_str": "IPv6Address",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv6Address",
              "desc": "Next IPv6 address value. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3154
          },
          "is_method": true,
          "signature": "IPv6Address:previous() → (\n      -- Previous IPv6 address value. \n)",
          "owner": "IPv6Address",
          "desc": "Return the previous IPv6 address.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "previous",
          "return_str": "IPv6Address",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv6Address",
              "desc": "Previous IPv6 address value. "
            }
          ],
          "params": []
        }
      ],
      "metamethods": [],
      "types": []
    },
    {
      "is_primary_export": false,
      "source": {
        "path": "",
        "line": 43
      },
      "tags": [],
      "properties": [
        {
          "tags": [],
          "lua_type": "version: number",
          "name": "version",
          "desc": "IP version number (`4`)."
        },
        {
          "tags": [],
          "lua_type": "_prefix: number",
          "name": "_prefix",
          "desc": "CIDR prefix length."
        },
        {
          "tags": [],
          "lua_type": "_network: number",
          "name": "_network",
          "desc": "Packed network address as 32-bit integer."
        }
      ],
      "desc": "Represents an IPv4 CIDR network.",
      "name": "IPv4Network",
      "functions": [
        {
          "source": {
            "path": "",
            "line": 1523
          },
          "is_method": false,
          "signature": "IPv4Network.smallestContaining(\n    a: IPv4Address,  -- First IPv4 address endpoint.\n    b: IPv4Address  -- Second IPv4 address endpoint.\n) → (\n      -- Minimal IPv4 CIDR block that covers both addresses. \n)",
          "owner": "IPv4Network",
          "desc": "Return the smallest IPv4 network containing both addresses.",
          "tags": [],
          "name": "smallestContaining",
          "return_str": "IPv4Network",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "IPv4Network",
              "desc": "Minimal IPv4 CIDR block that covers both addresses. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv4Address",
              "name": "a",
              "desc": "First IPv4 address endpoint."
            },
            {
              "lua_type": "IPv4Address",
              "name": "b",
              "desc": "Second IPv4 address endpoint."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 1647
          },
          "is_method": false,
          "signature": "IPv4Network.parse(\n    source: string,  -- IPv4 network text to parse.\n    options: ParseOptions?  -- Optional parse behavior flags.\n) → (\n      -- Parsed IPv4Network when the input is valid. \n)",
          "owner": "IPv4Network",
          "desc": "Parse an IPv4 CIDR network string with optional parse options.",
          "tags": [],
          "name": "parse",
          "return_str": "IPv4Network?",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "IPv4Network?",
              "desc": "Parsed IPv4Network when the input is valid. "
            }
          ],
          "params": [
            {
              "lua_type": "string",
              "name": "source",
              "desc": "IPv4 network text to parse."
            },
            {
              "lua_type": "ParseOptions?",
              "name": "options",
              "desc": "Optional parse behavior flags."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 1702
          },
          "is_method": false,
          "signature": "IPv4Network.mergeNetworks(\n    networks: { IPv4Network | string }  -- IPv4Network instances or parseable IPv4 CIDR strings.\n) → (\n      -- Minimal merged set of IPv4 networks. \n)",
          "owner": "IPv4Network",
          "desc": "Merge and collapse overlapping/adjacent IPv4 networks.",
          "tags": [],
          "name": "mergeNetworks",
          "return_str": "{ IPv4Network }",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "{ IPv4Network }",
              "desc": "Minimal merged set of IPv4 networks. "
            }
          ],
          "params": [
            {
              "lua_type": "{ IPv4Network | string }",
              "name": "networks",
              "desc": "IPv4Network instances or parseable IPv4 CIDR strings."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 3163
          },
          "is_method": true,
          "signature": "IPv4Network:networkAddress() → IPv4Address",
          "owner": "IPv4Network",
          "desc": "===== IPv4 Network =====",
          "tags": [],
          "name": "networkAddress",
          "return_str": "IPv4Address",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv4Address",
              "desc": ""
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3172
          },
          "is_method": true,
          "signature": "IPv4Network:broadcastAddress() → (\n      -- Broadcast address for this IPv4 network. \n)",
          "owner": "IPv4Network",
          "desc": "Return the broadcast address of this IPv4 CIDR block.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "broadcastAddress",
          "return_str": "IPv4Address",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv4Address",
              "desc": "Broadcast address for this IPv4 network. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3181
          },
          "is_method": true,
          "signature": "IPv4Network:netmask() → (\n      -- Netmask address for this IPv4 network. \n)",
          "owner": "IPv4Network",
          "desc": "Return the IPv4 netmask address for this prefix.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "netmask",
          "return_str": "IPv4Address",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv4Address",
              "desc": "Netmask address for this IPv4 network. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3189
          },
          "is_method": true,
          "signature": "IPv4Network:hostmask() → (\n      -- Hostmask address for this IPv4 network. \n)",
          "owner": "IPv4Network",
          "desc": "Return the IPv4 hostmask address for this prefix.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "hostmask",
          "return_str": "IPv4Address",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv4Address",
              "desc": "Hostmask address for this IPv4 network. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3197
          },
          "is_method": true,
          "signature": "IPv4Network:prefixLength() → (\n      -- Numeric result produced by the operation. \n)",
          "owner": "IPv4Network",
          "desc": "Return the CIDR prefix length for this IPv4 network.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "prefixLength",
          "return_str": "number",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "number",
              "desc": "Numeric result produced by the operation. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3205
          },
          "is_method": true,
          "signature": "IPv4Network:firstHost() → (\n      -- First usable host address in this network. \n)",
          "owner": "IPv4Network",
          "desc": "Return the first usable host address in this IPv4 network.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "firstHost",
          "return_str": "IPv4Address",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv4Address",
              "desc": "First usable host address in this network. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3217
          },
          "is_method": true,
          "signature": "IPv4Network:lastHost() → (\n      -- Last usable host address in this network. \n)",
          "owner": "IPv4Network",
          "desc": "Return the last usable host address in this IPv4 network.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "lastHost",
          "return_str": "IPv4Address",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv4Address",
              "desc": "Last usable host address in this network. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3230
          },
          "is_method": true,
          "signature": "IPv4Network:hostCount() → (\n      -- Numeric result produced by the operation. \n)",
          "owner": "IPv4Network",
          "desc": "Return the usable host count for this IPv4 network.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "hostCount",
          "return_str": "number",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "number",
              "desc": "Numeric result produced by the operation. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3244
          },
          "is_method": true,
          "signature": "IPv4Network:contains(\n    ipAddr: IPv4Address  -- IP address value to test against the network.\n) → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv4Network",
          "desc": "Return true if an IPv4 address belongs to this network.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "contains",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv4Address",
              "name": "ipAddr",
              "desc": "IP address value to test against the network."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 3255
          },
          "is_method": true,
          "signature": "IPv4Network:containsNetwork(\n    net: IPv4Network  -- Network to test membership, overlap, or containment against.\n) → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv4Network",
          "desc": "Return true if another IPv4 network is fully contained.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "containsNetwork",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv4Network",
              "name": "net",
              "desc": "Network to test membership, overlap, or containment against."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 3269
          },
          "is_method": true,
          "signature": "IPv4Network:overlaps(\n    net: IPv4Network  -- Network to test membership, overlap, or containment against.\n) → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv4Network",
          "desc": "Return true if two IPv4 networks overlap.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "overlaps",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv4Network",
              "name": "net",
              "desc": "Network to test membership, overlap, or containment against."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 3284
          },
          "is_method": true,
          "signature": "IPv4Network:isSubnetOf(\n    net: IPv4Network  -- Network to test membership, overlap, or containment against.\n) → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv4Network",
          "desc": "Return true if this network is a subnet of another IPv4 network.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isSubnetOf",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv4Network",
              "name": "net",
              "desc": "Network to test membership, overlap, or containment against."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 3293
          },
          "is_method": true,
          "signature": "IPv4Network:isSupernetOf(\n    net: IPv4Network  -- Network to test membership, overlap, or containment against.\n) → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv4Network",
          "desc": "Return true if this network is a supernet of another IPv4 network.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isSupernetOf",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv4Network",
              "name": "net",
              "desc": "Network to test membership, overlap, or containment against."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 3304
          },
          "is_method": true,
          "signature": "IPv4Network:subnets(\n    newPrefix: number?  -- Target prefix length for subnetting or supernetting.\n) → (\n      -- -> IPv4Network? Iterator yielding subnet networks at the requested prefix. \n)",
          "owner": "IPv4Network",
          "desc": "TODO: An __iter, not an array\n\nIterate child IPv4 subnets at the requested target prefix.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "subnets",
          "return_str": "(() → IPv4Network?)",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "(() → IPv4Network?)",
              "desc": "-> IPv4Network? Iterator yielding subnet networks at the requested prefix. "
            }
          ],
          "params": [
            {
              "lua_type": "number?",
              "name": "newPrefix",
              "desc": "Target prefix length for subnetting or supernetting."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 3329
          },
          "is_method": true,
          "signature": "IPv4Network:supernet(\n    newPrefix: number?  -- Target prefix length for subnetting or supernetting.\n) → (\n      -- Containing supernet at the requested prefix. \n)",
          "owner": "IPv4Network",
          "desc": "TODO: An __iter, not an array\n\nReturn the containing IPv4 supernet at the requested target prefix.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "supernet",
          "return_str": "IPv4Network",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv4Network",
              "desc": "Containing supernet at the requested prefix. "
            }
          ],
          "params": [
            {
              "lua_type": "number?",
              "name": "newPrefix",
              "desc": "Target prefix length for subnetting or supernetting."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 3343
          },
          "is_method": true,
          "signature": "IPv4Network:toIPv6Mapped() → (\n      -- IPv4-mapped IPv6 network with prefix shifted by 96 bits. \n)",
          "owner": "IPv4Network",
          "desc": "Return the IPv4 network mapped into IPv6 space.\n@param self Current IPv4Network instance.",
          "tags": [],
          "name": "toIPv6Mapped",
          "return_str": "IPv6Network",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv6Network",
              "desc": "IPv4-mapped IPv6 network with prefix shifted by 96 bits. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3364
          },
          "is_method": true,
          "signature": "IPv4Network:hosts() → (\n      -- -> IPv4Address? Iterator yielding usable IPv4 host addresses. \n)",
          "owner": "IPv4Network",
          "desc": "TODO: An __iter, not an array\n\nIterate usable IPv4 host addresses in this network lazily.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "hosts",
          "return_str": "(() → IPv4Address?)",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "(() → IPv4Address?)",
              "desc": "-> IPv4Address? Iterator yielding usable IPv4 host addresses. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3384
          },
          "is_method": true,
          "signature": "IPv4Network:addresses() → (\n      -- -> IPv4Address? Iterator yielding all IPv4 addresses in range. \n)",
          "owner": "IPv4Network",
          "desc": "TODO: An __iter, not an array\n\nIterate all IPv4 addresses in this network lazily.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "addresses",
          "return_str": "(() → IPv4Address?)",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "(() → IPv4Address?)",
              "desc": "-> IPv4Address? Iterator yielding all IPv4 addresses in range. "
            }
          ],
          "params": []
        }
      ],
      "metamethods": [],
      "types": []
    },
    {
      "is_primary_export": false,
      "source": {
        "path": "",
        "line": 61
      },
      "tags": [],
      "properties": [
        {
          "tags": [],
          "lua_type": "version: number",
          "name": "version",
          "desc": "IP version number (`6`)."
        },
        {
          "tags": [],
          "lua_type": "_prefix: number",
          "name": "_prefix",
          "desc": "CIDR prefix length."
        },
        {
          "tags": [],
          "lua_type": "_network: { number }",
          "name": "_network",
          "desc": "Network address as hextets."
        }
      ],
      "desc": "Represents an IPv6 CIDR network.",
      "name": "IPv6Network",
      "functions": [
        {
          "source": {
            "path": "",
            "line": 1537
          },
          "is_method": false,
          "signature": "IPv6Network.smallestContaining(\n    a: IPv6Address,  -- First IPv6 address endpoint.\n    b: IPv6Address  -- Second IPv6 address endpoint.\n) → (\n      -- Minimal IPv6 CIDR block that covers both addresses. \n)",
          "owner": "IPv6Network",
          "desc": "Return the smallest IPv6 network containing both addresses.",
          "tags": [],
          "name": "smallestContaining",
          "return_str": "IPv6Network",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "IPv6Network",
              "desc": "Minimal IPv6 CIDR block that covers both addresses. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv6Address",
              "name": "a",
              "desc": "First IPv6 address endpoint."
            },
            {
              "lua_type": "IPv6Address",
              "name": "b",
              "desc": "Second IPv6 address endpoint."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 1661
          },
          "is_method": false,
          "signature": "IPv6Network.parse(\n    source: string,  -- IPv6 network text to parse.\n    options: ParseOptions?  -- Optional parse behavior flags.\n) → (\n      -- Parsed IPv6Network when the input is valid. \n)",
          "owner": "IPv6Network",
          "desc": "Parse an IPv6 CIDR network string with optional parse options.",
          "tags": [],
          "name": "parse",
          "return_str": "IPv6Network?",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "IPv6Network?",
              "desc": "Parsed IPv6Network when the input is valid. "
            }
          ],
          "params": [
            {
              "lua_type": "string",
              "name": "source",
              "desc": "IPv6 network text to parse."
            },
            {
              "lua_type": "ParseOptions?",
              "name": "options",
              "desc": "Optional parse behavior flags."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 1764
          },
          "is_method": false,
          "signature": "IPv6Network.mergeNetworks(\n    networks: { IPv6Network | string }  -- IPv6Network instances or parseable IPv6 CIDR strings.\n) → (\n      -- Minimal merged set of IPv6 networks. \n)",
          "owner": "IPv6Network",
          "desc": "Merge and collapse overlapping/adjacent IPv6 networks.",
          "tags": [],
          "name": "mergeNetworks",
          "return_str": "{ IPv6Network }",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "{ IPv6Network }",
              "desc": "Minimal merged set of IPv6 networks. "
            }
          ],
          "params": [
            {
              "lua_type": "{ IPv6Network | string }",
              "name": "networks",
              "desc": "IPv6Network instances or parseable IPv6 CIDR strings."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 3399
          },
          "is_method": true,
          "signature": "IPv6Network:networkAddress() → IPv6Address",
          "owner": "IPv6Network",
          "desc": "===== IPv6 Network =====",
          "tags": [],
          "name": "networkAddress",
          "return_str": "IPv6Address",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv6Address",
              "desc": ""
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3407
          },
          "is_method": true,
          "signature": "IPv6Network:broadcastAddress() → (\n      -- Last address in this IPv6 network range. \n)",
          "owner": "IPv6Network",
          "desc": "Return the last address in this IPv6 CIDR block.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "broadcastAddress",
          "return_str": "IPv6Address",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv6Address",
              "desc": "Last address in this IPv6 network range. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3416
          },
          "is_method": true,
          "signature": "IPv6Network:netmask() → (\n      -- Netmask address for this IPv6 network. \n)",
          "owner": "IPv6Network",
          "desc": "Return the IPv6 netmask address for this prefix.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "netmask",
          "return_str": "IPv6Address",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv6Address",
              "desc": "Netmask address for this IPv6 network. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3426
          },
          "is_method": true,
          "signature": "IPv6Network:hostmask() → (\n      -- Hostmask address for this IPv6 network. \n)",
          "owner": "IPv6Network",
          "desc": "Return the IPv6 hostmask address for this prefix.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "hostmask",
          "return_str": "IPv6Address",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv6Address",
              "desc": "Hostmask address for this IPv6 network. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3434
          },
          "is_method": true,
          "signature": "IPv6Network:prefixLength() → (\n      -- Numeric result produced by the operation. \n)",
          "owner": "IPv6Network",
          "desc": "Return the CIDR prefix length for this IPv6 network.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "prefixLength",
          "return_str": "number",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "number",
              "desc": "Numeric result produced by the operation. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3442
          },
          "is_method": true,
          "signature": "IPv6Network:firstHost() → (\n      -- First address in this IPv6 network. \n)",
          "owner": "IPv6Network",
          "desc": "Return the first address in this IPv6 network.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "firstHost",
          "return_str": "IPv6Address",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv6Address",
              "desc": "First address in this IPv6 network. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3450
          },
          "is_method": true,
          "signature": "IPv6Network:lastHost() → (\n      -- Last address in this IPv6 network. \n)",
          "owner": "IPv6Network",
          "desc": "Return the last address in this IPv6 network.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "lastHost",
          "return_str": "IPv6Address",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv6Address",
              "desc": "Last address in this IPv6 network. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3459
          },
          "is_method": true,
          "signature": "IPv6Network:hostCount() → (\n      -- Numeric result produced by the operation. \n)",
          "owner": "IPv6Network",
          "desc": "Return address count for this IPv6 network.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "hostCount",
          "return_str": "number",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "number",
              "desc": "Numeric result produced by the operation. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3469
          },
          "is_method": true,
          "signature": "IPv6Network:contains(\n    ipAddr: IPv6Address  -- IP address value to test against the network.\n) → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv6Network",
          "desc": "Return true if an IPv6 address belongs to this network.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "contains",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv6Address",
              "name": "ipAddr",
              "desc": "IP address value to test against the network."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 3480
          },
          "is_method": true,
          "signature": "IPv6Network:containsNetwork(\n    net: IPv6Network  -- Network to test membership, overlap, or containment against.\n) → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv6Network",
          "desc": "Return true if another IPv6 network is fully contained.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "containsNetwork",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv6Network",
              "name": "net",
              "desc": "Network to test membership, overlap, or containment against."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 3494
          },
          "is_method": true,
          "signature": "IPv6Network:overlaps(\n    net: IPv6Network  -- Network to test membership, overlap, or containment against.\n) → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv6Network",
          "desc": "Return true if two IPv6 networks overlap.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "overlaps",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv6Network",
              "name": "net",
              "desc": "Network to test membership, overlap, or containment against."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 3509
          },
          "is_method": true,
          "signature": "IPv6Network:isSubnetOf(\n    net: IPv6Network  -- Network to test membership, overlap, or containment against.\n) → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv6Network",
          "desc": "Return true if this network is a subnet of another IPv6 network.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isSubnetOf",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv6Network",
              "name": "net",
              "desc": "Network to test membership, overlap, or containment against."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 3518
          },
          "is_method": true,
          "signature": "IPv6Network:isSupernetOf(\n    net: IPv6Network  -- Network to test membership, overlap, or containment against.\n) → (\n      -- result indicating whether the condition is met. \n)",
          "owner": "IPv6Network",
          "desc": "Return true if this network is a supernet of another IPv6 network.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "isSupernetOf",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "result indicating whether the condition is met. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv6Network",
              "name": "net",
              "desc": "Network to test membership, overlap, or containment against."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 3528
          },
          "is_method": true,
          "signature": "IPv6Network:subnets(\n    newPrefix: number?  -- Target prefix length for subnetting or supernetting.\n) → (\n      -- -> IPv6Network? Iterator yielding subnet networks at the requested prefix. \n)",
          "owner": "IPv6Network",
          "desc": "TODO: An __iter, not an array\n\nIterate child IPv6 subnets at the requested target prefix.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "subnets",
          "return_str": "(() → IPv6Network?)",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "(() → IPv6Network?)",
              "desc": "-> IPv6Network? Iterator yielding subnet networks at the requested prefix. "
            }
          ],
          "params": [
            {
              "lua_type": "number?",
              "name": "newPrefix",
              "desc": "Target prefix length for subnetting or supernetting."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 3562
          },
          "is_method": true,
          "signature": "IPv6Network:supernet(\n    newPrefix: number?  -- Target prefix length for subnetting or supernetting.\n) → (\n      -- Containing supernet at the requested prefix. \n)",
          "owner": "IPv6Network",
          "desc": "TODO: An __iter, not an array\n\nReturn the containing IPv6 supernet at the requested target prefix.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "supernet",
          "return_str": "IPv6Network",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv6Network",
              "desc": "Containing supernet at the requested prefix. "
            }
          ],
          "params": [
            {
              "lua_type": "number?",
              "name": "newPrefix",
              "desc": "Target prefix length for subnetting or supernetting."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 3576
          },
          "is_method": true,
          "signature": "IPv6Network:hosts() → (\n      -- -> IPv6Address? Iterator yielding IPv6 host addresses in range. \n)",
          "owner": "IPv6Network",
          "desc": "TODO: An __iter, not an array\n\nIterate IPv6 host addresses lazily (same sequence as addresses).\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "hosts",
          "return_str": "(() → IPv6Address?)",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "(() → IPv6Address?)",
              "desc": "-> IPv6Address? Iterator yielding IPv6 host addresses in range. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3585
          },
          "is_method": true,
          "signature": "IPv6Network:addresses() → (\n      -- -> IPv6Address? Iterator yielding IPv6 addresses in range. \n)",
          "owner": "IPv6Network",
          "desc": "TODO: An __iter, not an array\n\nIterate IPv6 addresses in this network lazily.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "addresses",
          "return_str": "(() → IPv6Address?)",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "(() → IPv6Address?)",
              "desc": "-> IPv6Address? Iterator yielding IPv6 addresses in range. "
            }
          ],
          "params": []
        }
      ],
      "metamethods": [],
      "types": []
    },
    {
      "is_primary_export": false,
      "source": {
        "path": "",
        "line": 79
      },
      "tags": [],
      "properties": [
        {
          "tags": [],
          "lua_type": "address: IPv4Address",
          "name": "address",
          "desc": "Assigned IPv4 address."
        },
        {
          "tags": [],
          "lua_type": "network: IPv4Network",
          "name": "network",
          "desc": "Containing IPv4 network."
        },
        {
          "tags": [],
          "lua_type": "_prefix: number",
          "name": "_prefix",
          "desc": "Interface prefix length."
        }
      ],
      "desc": "Represents an IPv4 interface assignment (`address/prefix`).",
      "name": "IPv4Interface",
      "functions": [
        {
          "source": {
            "path": "",
            "line": 1675
          },
          "is_method": false,
          "signature": "IPv4Interface.parse(\n    source: string,  -- IPv4 interface text (`address/prefix`) to parse.\n    options: ParseOptions?  -- Optional parse behavior flags.\n) → (\n      -- Parsed IPv4Interface when the input is valid. \n)",
          "owner": "IPv4Interface",
          "desc": "Parse an IPv4 interface string with optional parse options.",
          "tags": [],
          "name": "parse",
          "return_str": "IPv4Interface?",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "IPv4Interface?",
              "desc": "Parsed IPv4Interface when the input is valid. "
            }
          ],
          "params": [
            {
              "lua_type": "string",
              "name": "source",
              "desc": "IPv4 interface text (`address/prefix`) to parse."
            },
            {
              "lua_type": "ParseOptions?",
              "name": "options",
              "desc": "Optional parse behavior flags."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 3613
          },
          "is_method": true,
          "signature": "IPv4Interface:prefixLength() → (\n      -- Numeric result produced by the operation. \n)",
          "owner": "IPv4Interface",
          "desc": "Return interface prefix length.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "prefixLength",
          "return_str": "number",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "number",
              "desc": "Numeric result produced by the operation. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3621
          },
          "is_method": true,
          "signature": "IPv4Interface:netmask() → (\n      -- Netmask for this IPv4 interface. \n)",
          "owner": "IPv4Interface",
          "desc": "Return interface IPv4 netmask.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "netmask",
          "return_str": "IPv4Address",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv4Address",
              "desc": "Netmask for this IPv4 interface. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3625
          },
          "is_method": true,
          "signature": "IPv4Interface:withPrefixLength() → string",
          "owner": "IPv4Interface",
          "desc": "eg \"192.168.1.10/24\"",
          "tags": [],
          "name": "withPrefixLength",
          "return_str": "string",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "string",
              "desc": ""
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3629
          },
          "is_method": true,
          "signature": "IPv4Interface:withNetmask() → string",
          "owner": "IPv4Interface",
          "desc": "eg \"192.168.1.10/255.255.255.0\"",
          "tags": [],
          "name": "withNetmask",
          "return_str": "string",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "string",
              "desc": ""
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3637
          },
          "is_method": true,
          "signature": "IPv4Interface:hostmask() → (\n      -- Hostmask for this IPv4 interface. \n)",
          "owner": "IPv4Interface",
          "desc": "Return interface IPv4 hostmask.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "hostmask",
          "return_str": "IPv4Address",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv4Address",
              "desc": "Hostmask for this IPv4 interface. "
            }
          ],
          "params": []
        }
      ],
      "metamethods": [],
      "types": []
    },
    {
      "is_primary_export": false,
      "source": {
        "path": "",
        "line": 97
      },
      "tags": [],
      "properties": [
        {
          "tags": [],
          "lua_type": "address: IPv6Address",
          "name": "address",
          "desc": "Assigned IPv6 address."
        },
        {
          "tags": [],
          "lua_type": "network: IPv6Network",
          "name": "network",
          "desc": "Containing IPv6 network."
        },
        {
          "tags": [],
          "lua_type": "_prefix: number",
          "name": "_prefix",
          "desc": "Interface prefix length."
        }
      ],
      "desc": "Represents an IPv6 interface assignment (`address/prefix`).",
      "name": "IPv6Interface",
      "functions": [
        {
          "source": {
            "path": "",
            "line": 1689
          },
          "is_method": false,
          "signature": "IPv6Interface.parse(\n    source: string,  -- IPv6 interface text (`address/prefix`) to parse.\n    options: ParseOptions?  -- Optional parse behavior flags.\n) → (\n      -- Parsed IPv6Interface when the input is valid. \n)",
          "owner": "IPv6Interface",
          "desc": "Parse an IPv6 interface string with optional parse options.",
          "tags": [],
          "name": "parse",
          "return_str": "IPv6Interface?",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "IPv6Interface?",
              "desc": "Parsed IPv6Interface when the input is valid. "
            }
          ],
          "params": [
            {
              "lua_type": "string",
              "name": "source",
              "desc": "IPv6 interface text (`address/prefix`) to parse."
            },
            {
              "lua_type": "ParseOptions?",
              "name": "options",
              "desc": "Optional parse behavior flags."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 3648
          },
          "is_method": true,
          "signature": "IPv6Interface:prefixLength() → (\n      -- Numeric result produced by the operation. \n)",
          "owner": "IPv6Interface",
          "desc": "Return interface prefix length.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "prefixLength",
          "return_str": "number",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "number",
              "desc": "Numeric result produced by the operation. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3656
          },
          "is_method": true,
          "signature": "IPv6Interface:netmask() → (\n      -- Netmask for this IPv6 interface. \n)",
          "owner": "IPv6Interface",
          "desc": "Return interface IPv6 netmask.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "netmask",
          "return_str": "IPv6Address",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv6Address",
              "desc": "Netmask for this IPv6 interface. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3660
          },
          "is_method": true,
          "signature": "IPv6Interface:withPrefixLength() → string",
          "owner": "IPv6Interface",
          "desc": "eg \"192.168.1.10/26\" (but ipv6)",
          "tags": [],
          "name": "withPrefixLength",
          "return_str": "string",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "string",
              "desc": ""
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3664
          },
          "is_method": true,
          "signature": "IPv6Interface:withNetmask() → string",
          "owner": "IPv6Interface",
          "desc": "eg \"192.168.1.10/255.255.255.0\" (but ipv6)",
          "tags": [],
          "name": "withNetmask",
          "return_str": "string",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "string",
              "desc": ""
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 3672
          },
          "is_method": true,
          "signature": "IPv6Interface:hostmask() → (\n      -- Hostmask for this IPv6 interface. \n)",
          "owner": "IPv6Interface",
          "desc": "Return interface IPv6 hostmask.\n@param self Current object instance on which the method operates.",
          "tags": [],
          "name": "hostmask",
          "return_str": "IPv6Address",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv6Address",
              "desc": "Hostmask for this IPv6 interface. "
            }
          ],
          "params": []
        }
      ],
      "metamethods": [],
      "types": []
    },
    {
      "is_primary_export": false,
      "source": {
        "path": "",
        "line": 115
      },
      "tags": [],
      "properties": [
        {
          "tags": [],
          "lua_type": "version: number",
          "name": "version",
          "desc": "IP version number (`4`)."
        },
        {
          "tags": [],
          "lua_type": "_segments: { { start: number, finish: number } }",
          "name": "_segments",
          "desc": "Sorted, non-overlapping inclusive segments."
        }
      ],
      "desc": "Represents a normalized set of IPv4 segments.",
      "name": "IPv4Range",
      "functions": [
        {
          "source": {
            "path": "",
            "line": 1828
          },
          "is_method": false,
          "signature": "IPv4Range.new(\n    startValue: IPv4Address | string,  -- Start address for the range, as IPv4Address or IPv4 string.\n    endValue: IPv4Address | string  -- End address for the range, as IPv4Address or IPv4 string.\n) → (\n      -- IPv4Range covering the inclusive start/end interval. \n)",
          "owner": "IPv4Range",
          "desc": "Build an IPv4 range from start and end addresses (inclusive).",
          "tags": [],
          "name": "new",
          "return_str": "IPv4Range",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "IPv4Range",
              "desc": "IPv4Range covering the inclusive start/end interval. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv4Address | string",
              "name": "startValue",
              "desc": "Start address for the range, as IPv4Address or IPv4 string."
            },
            {
              "lua_type": "IPv4Address | string",
              "name": "endValue",
              "desc": "End address for the range, as IPv4Address or IPv4 string."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 1847
          },
          "is_method": false,
          "signature": "IPv4Range.fromNetwork(\n    networkValue: IPv4Network | string  -- IPv4Network instance or parseable IPv4 CIDR string.\n) → (\n      -- IPv4Range covering every address in the network. \n)",
          "owner": "IPv4Range",
          "desc": "Create an IPv4 range that exactly matches a CIDR network.",
          "tags": [],
          "name": "fromNetwork",
          "return_str": "IPv4Range",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "IPv4Range",
              "desc": "IPv4Range covering every address in the network. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv4Network | string",
              "name": "networkValue",
              "desc": "IPv4Network instance or parseable IPv4 CIDR string."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 2091
          },
          "is_method": true,
          "signature": "IPv4Range:contains(\n    value: IPv4Address | IPv4Network | IPv4Range | string  -- IPv4Address, IPv4Network, IPv4Range, or parseable string input.\n) → (\n      -- True when the entire value is contained by this range. \n)",
          "owner": "IPv4Range",
          "desc": "Check whether an IPv4 range contains the supplied value.\n@param self Current IPv4Range instance.",
          "tags": [],
          "name": "contains",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "True when the entire value is contained by this range. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv4Address | IPv4Network | IPv4Range | string",
              "name": "value",
              "desc": "IPv4Address, IPv4Network, IPv4Range, or parseable string input."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 2165
          },
          "is_method": true,
          "signature": "IPv4Range:exclude(\n    value: IPv4Address | IPv4Network | IPv4Range | string  -- IPv4Address, IPv4Network, IPv4Range, or parseable string input.\n) → (\n      -- New IPv4Range after subtraction. \n)",
          "owner": "IPv4Range",
          "desc": "Return a new IPv4 range with the supplied address/network/range removed.\n@param self Current IPv4Range instance.",
          "tags": [],
          "name": "exclude",
          "return_str": "IPv4Range",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv4Range",
              "desc": "New IPv4Range after subtraction. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv4Address | IPv4Network | IPv4Range | string",
              "name": "value",
              "desc": "IPv4Address, IPv4Network, IPv4Range, or parseable string input."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 2208
          },
          "is_method": true,
          "signature": "IPv4Range:iter() → (\n      -- -> IPv4Address? Iterator yielding IPv4 addresses in ascending order. \n)",
          "owner": "IPv4Range",
          "desc": "Lazily iterate all IPv4 addresses in this range.\n@param self Current IPv4Range instance.",
          "tags": [],
          "name": "iter",
          "return_str": "(() → IPv4Address?)",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "(() → IPv4Address?)",
              "desc": "-> IPv4Address? Iterator yielding IPv4 addresses in ascending order. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2272
          },
          "is_method": true,
          "signature": "IPv4Range:toNetworks() → (\n      -- -> IPv4Network? Iterator yielding minimal IPv4 CIDR blocks. \n)",
          "owner": "IPv4Range",
          "desc": "Lazily enumerate exact covering IPv4 CIDR blocks for this range.\n@param self Current IPv4Range instance.",
          "tags": [],
          "name": "toNetworks",
          "return_str": "(() → IPv4Network?)",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "(() → IPv4Network?)",
              "desc": "-> IPv4Network? Iterator yielding minimal IPv4 CIDR blocks. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2362
          },
          "is_method": true,
          "signature": "IPv4Range:smallestContainingNetwork() → (\n      -- Smallest containing IPv4 network, potentially including extra addresses. \n)",
          "owner": "IPv4Range",
          "desc": "Return the single smallest IPv4 CIDR that contains this entire range.\n@param self Current IPv4Range instance.",
          "tags": [],
          "name": "smallestContainingNetwork",
          "return_str": "IPv4Network",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv4Network",
              "desc": "Smallest containing IPv4 network, potentially including extra addresses. "
            }
          ],
          "params": []
        }
      ],
      "metamethods": [],
      "types": []
    },
    {
      "is_primary_export": false,
      "source": {
        "path": "",
        "line": 131
      },
      "tags": [],
      "properties": [
        {
          "tags": [],
          "lua_type": "version: number",
          "name": "version",
          "desc": "IP version number (`6`)."
        },
        {
          "tags": [],
          "lua_type": "_segments: { { start: { number }, finish: { number } } }",
          "name": "_segments",
          "desc": "Sorted, non-overlapping inclusive segments."
        }
      ],
      "desc": "Represents a normalized set of IPv6 segments.",
      "name": "IPv6Range",
      "functions": [
        {
          "source": {
            "path": "",
            "line": 1863
          },
          "is_method": false,
          "signature": "IPv6Range.new(\n    startValue: IPv6Address | string,  -- Start address for the range, as IPv6Address or IPv6 string.\n    endValue: IPv6Address | string  -- End address for the range, as IPv6Address or IPv6 string.\n) → (\n      -- IPv6Range covering the inclusive start/end interval. \n)",
          "owner": "IPv6Range",
          "desc": "Build an IPv6 range from start and end addresses (inclusive).",
          "tags": [],
          "name": "new",
          "return_str": "IPv6Range",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "IPv6Range",
              "desc": "IPv6Range covering the inclusive start/end interval. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv6Address | string",
              "name": "startValue",
              "desc": "Start address for the range, as IPv6Address or IPv6 string."
            },
            {
              "lua_type": "IPv6Address | string",
              "name": "endValue",
              "desc": "End address for the range, as IPv6Address or IPv6 string."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 1882
          },
          "is_method": false,
          "signature": "IPv6Range.fromNetwork(\n    networkValue: IPv6Network | string  -- IPv6Network instance or parseable IPv6 CIDR string.\n) → (\n      -- IPv6Range covering every address in the network. \n)",
          "owner": "IPv6Range",
          "desc": "Create an IPv6 range that exactly matches a CIDR network.",
          "tags": [],
          "name": "fromNetwork",
          "return_str": "IPv6Range",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "IPv6Range",
              "desc": "IPv6Range covering every address in the network. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv6Network | string",
              "name": "networkValue",
              "desc": "IPv6Network instance or parseable IPv6 CIDR string."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 2125
          },
          "is_method": true,
          "signature": "IPv6Range:contains(\n    value: IPv6Address | IPv6Network | IPv6Range | string  -- IPv6Address, IPv6Network, IPv6Range, or parseable string input.\n) → (\n      -- True when the entire value is contained by this range. \n)",
          "owner": "IPv6Range",
          "desc": "Check whether an IPv6 range contains the supplied value.\n@param self Current IPv6Range instance.",
          "tags": [],
          "name": "contains",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "True when the entire value is contained by this range. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv6Address | IPv6Network | IPv6Range | string",
              "name": "value",
              "desc": "IPv6Address, IPv6Network, IPv6Range, or parseable string input."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 2187
          },
          "is_method": true,
          "signature": "IPv6Range:exclude(\n    value: IPv6Address | IPv6Network | IPv6Range | string  -- IPv6Address, IPv6Network, IPv6Range, or parseable string input.\n) → (\n      -- New IPv6Range after subtraction. \n)",
          "owner": "IPv6Range",
          "desc": "Return a new IPv6 range with the supplied address/network/range removed.\n@param self Current IPv6Range instance.",
          "tags": [],
          "name": "exclude",
          "return_str": "IPv6Range",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv6Range",
              "desc": "New IPv6Range after subtraction. "
            }
          ],
          "params": [
            {
              "lua_type": "IPv6Address | IPv6Network | IPv6Range | string",
              "name": "value",
              "desc": "IPv6Address, IPv6Network, IPv6Range, or parseable string input."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 2240
          },
          "is_method": true,
          "signature": "IPv6Range:iter() → (\n      -- -> IPv6Address? Iterator yielding IPv6 addresses in ascending order. \n)",
          "owner": "IPv6Range",
          "desc": "Lazily iterate all IPv6 addresses in this range.\n@param self Current IPv6Range instance.",
          "tags": [],
          "name": "iter",
          "return_str": "(() → IPv6Address?)",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "(() → IPv6Address?)",
              "desc": "-> IPv6Address? Iterator yielding IPv6 addresses in ascending order. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2317
          },
          "is_method": true,
          "signature": "IPv6Range:toNetworks() → (\n      -- -> IPv6Network? Iterator yielding minimal IPv6 CIDR blocks. \n)",
          "owner": "IPv6Range",
          "desc": "Lazily enumerate exact covering IPv6 CIDR blocks for this range.\n@param self Current IPv6Range instance.",
          "tags": [],
          "name": "toNetworks",
          "return_str": "(() → IPv6Network?)",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "(() → IPv6Network?)",
              "desc": "-> IPv6Network? Iterator yielding minimal IPv6 CIDR blocks. "
            }
          ],
          "params": []
        },
        {
          "source": {
            "path": "",
            "line": 2377
          },
          "is_method": true,
          "signature": "IPv6Range:smallestContainingNetwork() → (\n      -- Smallest containing IPv6 network, potentially including extra addresses. \n)",
          "owner": "IPv6Range",
          "desc": "Return the single smallest IPv6 CIDR that contains this entire range.\n@param self Current IPv6Range instance.",
          "tags": [],
          "name": "smallestContainingNetwork",
          "return_str": "IPv6Network",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "IPv6Network",
              "desc": "Smallest containing IPv6 network, potentially including extra addresses. "
            }
          ],
          "params": []
        }
      ],
      "metamethods": [],
      "types": []
    }
  ]
}