{
  "classes": [
    {
      "constants": [],
      "types": [],
      "name": "@eryx/schema/struct",
      "tags": [],
      "functions": [
        {
          "source": {
            "path": "",
            "line": 300
          },
          "is_method": false,
          "signature": "schema.strict<T>(\n    struct: TableSchema<T>\n) → (\n      -- A new table schema in strict mode. \n)",
          "owner": "schema",
          "desc": "Set unknown-key handling to strict mode.\nUnknown keys fail parsing.\nUse strict mode for closed contracts, API request validation, and places\nwhere extra fields likely indicate caller errors.",
          "tags": [],
          "name": "strict",
          "return_str": "TableSchema<T>",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "TableSchema<T>",
              "desc": "A new table schema in strict mode. "
            }
          ],
          "params": [
            {
              "lua_type": "TableSchema<T>",
              "name": "struct",
              "desc": ""
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 311
          },
          "is_method": false,
          "signature": "schema.strip<T>(\n    struct: TableSchema<T>\n) → (\n      -- A new table schema in strip mode. \n)",
          "owner": "schema",
          "desc": "Set unknown-key handling to strip mode.\nUnknown keys are accepted but removed from parsed output.\nUse strip mode at permissive boundaries when forward compatibility is\ndesired but unknown fields should not propagate internally.",
          "tags": [],
          "name": "strip",
          "return_str": "TableSchema<T>",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "TableSchema<T>",
              "desc": "A new table schema in strip mode. "
            }
          ],
          "params": [
            {
              "lua_type": "TableSchema<T>",
              "name": "struct",
              "desc": ""
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 322
          },
          "is_method": false,
          "signature": "schema.passthrough<T>(\n    struct: TableSchema<T>\n) → (\n      -- A new table schema in passthrough mode. \n)",
          "owner": "schema",
          "desc": "Set unknown-key handling to passthrough mode.\nUnknown keys are accepted and retained in parsed output.\nUse passthrough mode when extension fields are expected and should remain\navailable to callers or downstream systems.",
          "tags": [],
          "name": "passthrough",
          "return_str": "TableSchema<T>",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "TableSchema<T>",
              "desc": "A new table schema in passthrough mode. "
            }
          ],
          "params": [
            {
              "lua_type": "TableSchema<T>",
              "name": "struct",
              "desc": ""
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 334
          },
          "is_method": false,
          "signature": "schema.catchall<T>(\n    struct: TableSchema<T>,\n    child: t.Schema<any>  -- Schema applied to unknown keys when catchall is enabled.\n) → (\n      -- A new table schema with catchall validation. \n)",
          "owner": "schema",
          "desc": "Validate unknown keys using a catchall schema.\nCatchall applies schema validation to keys not listed in `fields`.\nCombine with strip/passthrough depending on whether validated extras should\nbe dropped or retained in parsed output.",
          "tags": [],
          "name": "catchall",
          "return_str": "TableSchema<T>",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "TableSchema<T>",
              "desc": "A new table schema with catchall validation. "
            }
          ],
          "params": [
            {
              "lua_type": "TableSchema<T>",
              "name": "struct",
              "desc": ""
            },
            {
              "lua_type": "t.Schema<any>",
              "name": "child",
              "desc": "Schema applied to unknown keys when catchall is enabled."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 344
          },
          "is_method": false,
          "signature": "schema.partial<T>(\n    struct: TableSchema<T>\n) → (\n      -- A new table schema with optionalized fields. \n)",
          "owner": "schema",
          "desc": "Make all fields optional.\nIdeal for PATCH-style inputs and partial update payloads.\nExisting optional fields remain optional; required fields are wrapped.",
          "tags": [],
          "name": "partial",
          "return_str": "TableSchema<any>",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "TableSchema<any>",
              "desc": "A new table schema with optionalized fields. "
            }
          ],
          "params": [
            {
              "lua_type": "TableSchema<T>",
              "name": "struct",
              "desc": ""
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 365
          },
          "is_method": false,
          "signature": "schema.pick<T>(\n    struct: TableSchema<T>,\n    keys: { string }  -- Field names to keep in the resulting schema.\n) → (\n      -- A new table schema containing picked fields. \n)",
          "owner": "schema",
          "desc": "Keep only the selected field keys.\nUseful for endpoint/view-specific projections built from a shared base shape.",
          "tags": [],
          "name": "pick",
          "return_str": "TableSchema<any>",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "TableSchema<any>",
              "desc": "A new table schema containing picked fields. "
            }
          ],
          "params": [
            {
              "lua_type": "TableSchema<T>",
              "name": "struct",
              "desc": ""
            },
            {
              "lua_type": "{ string }",
              "name": "keys",
              "desc": "Field names to keep in the resulting schema."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 387
          },
          "is_method": false,
          "signature": "schema.omit<T>(\n    struct: TableSchema<T>,\n    keys: { string }  -- Field names to remove from the resulting schema.\n) → (\n      -- A new table schema without omitted fields. \n)",
          "owner": "schema",
          "desc": "Drop the selected field keys.\nUseful for deriving public-facing shapes from internal objects.",
          "tags": [],
          "name": "omit",
          "return_str": "TableSchema<any>",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "TableSchema<any>",
              "desc": "A new table schema without omitted fields. "
            }
          ],
          "params": [
            {
              "lua_type": "TableSchema<T>",
              "name": "struct",
              "desc": ""
            },
            {
              "lua_type": "{ string }",
              "name": "keys",
              "desc": "Field names to remove from the resulting schema."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 411
          },
          "is_method": false,
          "signature": "schema.required<T>(\n    struct: TableSchema<T>,\n    keys: { string }?  -- Optional subset of fields to force as required.\n) → (\n      -- A new table schema with required fields. \n)",
          "owner": "schema",
          "desc": "Make fields required by unwrapping optional wrappers.\nIf keys are omitted, all fields are made required.\nUse keyed required mode to tighten selected fields while preserving the\nrest of a partial schema.",
          "tags": [],
          "name": "required",
          "return_str": "TableSchema<any>",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "TableSchema<any>",
              "desc": "A new table schema with required fields. "
            }
          ],
          "params": [
            {
              "lua_type": "TableSchema<T>",
              "name": "struct",
              "desc": ""
            },
            {
              "lua_type": "{ string }?",
              "name": "keys",
              "desc": "Optional subset of fields to force as required."
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 435
          },
          "is_method": false,
          "signature": "schema.readonly<T>(\n    struct: TableSchema<T>\n) → (\n      -- A new table schema that freezes parsed results. \n)",
          "owner": "schema",
          "desc": "Freeze parsed output tables so downstream code cannot mutate them.\nUseful when parsed data should be treated as immutable configuration or\nvalue objects.",
          "tags": [],
          "name": "readonly",
          "return_str": "TableSchema<T>",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "TableSchema<T>",
              "desc": "A new table schema that freezes parsed results. "
            }
          ],
          "params": [
            {
              "lua_type": "TableSchema<T>",
              "name": "struct",
              "desc": ""
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 444
          },
          "is_method": false,
          "signature": "schema.freeze<T>(\n    struct: TableSchema<T>\n) → (\n      -- A new table schema that freezes parsed results. \n)",
          "owner": "schema",
          "desc": "Alias for readonly table output.\nProvided for naming parity with libraries that expose `freeze`.",
          "tags": [],
          "name": "freeze",
          "return_str": "TableSchema<T>",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "TableSchema<T>",
              "desc": "A new table schema that freezes parsed results. "
            }
          ],
          "params": [
            {
              "lua_type": "TableSchema<T>",
              "name": "struct",
              "desc": ""
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 457
          },
          "is_method": false,
          "signature": "schema.extend<T, U>(\n    first: TableSchema<T>,  -- Left/base table schema whose policies are retained.\n    second: U  -- Right/extension table schema whose fields are merged in.\n) → (\n      -- A merged table schema. \n)",
          "owner": "schema",
          "desc": "Merge fields from two table schemas.\nWhen keys overlap, the second schema's field definition wins.\nThe resulting schema keeps policy metadata from the first schema.\nUse this to build layered shapes from reusable fragments.",
          "tags": [],
          "name": "extend",
          "return_str": "TableSchema<mergeTables<T, extractTableSchema<U>>>",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "TableSchema<mergeTables<T, extractTableSchema<U>>>",
              "desc": "A merged table schema. "
            }
          ],
          "params": [
            {
              "lua_type": "TableSchema<T>",
              "name": "first",
              "desc": "Left/base table schema whose policies are retained."
            },
            {
              "lua_type": "U",
              "name": "second",
              "desc": "Right/extension table schema whose fields are merged in."
            }
          ]
        }
      ],
      "properties": [],
      "source": {
        "path": "",
        "line": 0
      },
      "desc": "Struct (table) schema primitives.\nSupports field validation, unknown-key policies, schema transforms, and shape composition.\nThis module is the primary tool for object-like contracts where each key\nhas its own schema and unknown-key behavior must be explicit.\n"
    }
  ]
}