{
  "$defs": {
    "AdapterConfig": {
      "description": "Configuration for a single adapter.",
      "properties": {
        "core_path": {
          "description": "Full Rust path to the core function/method (e.g., \"sample_markdown_rs::convert\")",
          "type": "string"
        },
        "detect_async": {
          "default": false,
          "description": "For callback_bridge: whether to detect async callbacks at construction time",
          "type": "boolean"
        },
        "error_type": {
          "description": "Error type name",
          "type": [
            "string",
            "null"
          ]
        },
        "gil_release": {
          "default": false,
          "description": "For Python: release GIL during call",
          "type": "boolean"
        },
        "item_type": {
          "description": "For streaming: the item type",
          "type": [
            "string",
            "null"
          ]
        },
        "name": {
          "type": "string"
        },
        "owner_type": {
          "description": "For async_method/streaming: the owning type name",
          "type": [
            "string",
            "null"
          ]
        },
        "params": {
          "default": [],
          "description": "Parameters",
          "items": {
            "$ref": "#/$defs/AdapterParam"
          },
          "type": "array"
        },
        "pattern": {
          "$ref": "#/$defs/AdapterPattern"
        },
        "request_type": {
          "default": null,
          "description": "For streaming (FFI backend): full Rust type path of the request payload\ndeserialised from JSON (e.g. `\"my_crate::ChatCompletionRequest\"`).\nRequired when generating FFI streaming bodies — codegen will hard-fail\nwith a clear error if this field is absent on a streaming adapter.",
          "type": [
            "string",
            "null"
          ]
        },
        "returns": {
          "description": "Return type name",
          "type": [
            "string",
            "null"
          ]
        },
        "skip_languages": {
          "default": [],
          "description": "Language backends for which this adapter should NOT be emitted.\n\nMirrors the same field on `[[crates.e2e.calls.*]]`. Useful when a\nconsumer's core crate cannot compile on a given target (e.g.\na streaming crate on `wasm32-unknown-unknown` which has no working async\nruntime for streaming). The adapter remains declared for every backend\nwhere it works, with explicit per-backend opt-out rather than removing\nthe adapter entirely.\n\nValues must match the canonical TOML language names used in `languages`\n(`\"python\"`, `\"node\"`, `\"wasm\"`, `\"ruby\"`, `\"php\"`, `\"go\"`,\n`\"java\"`, `\"csharp\"`, `\"elixir\"`, `\"kotlin\"`, `\"kotlin_android\"`,\n`\"swift\"`, `\"dart\"`, `\"zig\"`, `\"ffi\"`, `\"r\"`, `\"gleam\"`, `\"c\"`,\n`\"jni\"`, `\"rust\"`). An unknown name fails at config-resolve time.\n\nExample: `skip_languages = [\"wasm\", \"kotlin\"]`",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "trait_method": {
          "default": null,
          "description": "For callback_bridge: the trait method name (e.g., \"handle\")",
          "type": [
            "string",
            "null"
          ]
        },
        "trait_name": {
          "default": null,
          "description": "For callback_bridge: the Rust trait to implement (e.g., \"MyHandler\")",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "required": [
        "name",
        "pattern",
        "core_path"
      ],
      "type": "object"
    },
    "AdapterParam": {
      "description": "A parameter in an adapter function.",
      "properties": {
        "name": {
          "type": "string"
        },
        "optional": {
          "default": false,
          "type": "boolean"
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "name",
        "type"
      ],
      "type": "object"
    },
    "AdapterPattern": {
      "description": "The kind of adapter pattern.",
      "enum": [
        "sync_function",
        "async_method",
        "callback_bridge",
        "streaming"
      ],
      "type": "string"
    },
    "ArgMapping": {
      "description": "Maps a fixture input field to a function argument.",
      "properties": {
        "element_type": {
          "default": null,
          "description": "For `json_object` args targeting `&[T]` Rust parameters, set to the element type\n(e.g. `\"f32\"`, `\"String\"`) so the codegen emits `Vec<element_type>` annotation.",
          "type": [
            "string",
            "null"
          ]
        },
        "field": {
          "description": "JSON field path in the fixture's `input` object.",
          "type": "string"
        },
        "go_type": {
          "default": null,
          "description": "Override the Go slice element type for `json_object` array args.\n\nWhen set, the Go e2e codegen uses this as the element type instead of the default\nderived from `element_type`. Use Go-idiomatic type names including the import alias\nprefix where needed, e.g. `\"sample_core.BatchBytesItem\"` or `\"string\"`.",
          "type": [
            "string",
            "null"
          ]
        },
        "name": {
          "description": "Argument name in the function signature.",
          "type": "string"
        },
        "optional": {
          "default": false,
          "description": "Whether this argument is optional.",
          "type": "boolean"
        },
        "owned": {
          "default": false,
          "description": "When `true`, the Rust codegen passes this argument by value (owned) rather than\nby reference. Use for `Vec<T>` parameters that do not accept `&Vec<T>`.",
          "type": "boolean"
        },
        "trait_name": {
          "default": null,
          "description": "Trait name for `test_backend` arg type (e.g., `\"DocumentExtractor\"`, `\"OcrBackend\"`).\n\nWhen `arg_type = \"test_backend\"`, this field specifies which trait's bridge\ncodegen should be used to create the test stub instance. Only used when\n`arg_type = \"test_backend\"`.",
          "type": [
            "string",
            "null"
          ]
        },
        "type": {
          "default": "string",
          "description": "Type hint for code generation.",
          "type": "string"
        },
        "vec_inner_is_ref": {
          "default": false,
          "description": "When `true`, the Rust e2e codegen converts `Vec<String>` to `Vec<&str>` before the\ncall, enabling the slice to coerce to `&[&str]` as required by the Rust core.\n\nUse when `arg_type = \"json_object\"` and `element_type = \"String\"` and the target\nRust function parameter is `&[&str]` (not `&[String]`).",
          "type": "boolean"
        }
      },
      "required": [
        "name",
        "field"
      ],
      "type": "object"
    },
    "BridgeBinding": {
      "description": "How a trait bridge attaches to the public API.\n\nSee [`TraitBridgeConfig::bind_via`] for the user-facing description.",
      "oneOf": [
        {
          "const": "function_param",
          "description": "The bridge arrives as a positional function argument. Legacy default.",
          "type": "string"
        },
        {
          "const": "options_field",
          "description": "The bridge lives as a field on a configured options struct.",
          "type": "string"
        }
      ]
    },
    "BuildCommandConfig": {
      "properties": {
        "before": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ],
          "description": "Command(s) to run before the main build commands; aborts on failure."
        },
        "build": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ],
          "description": "Command(s) to build in debug mode."
        },
        "build_release": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ],
          "description": "Command(s) to build in release mode."
        },
        "precondition": {
          "description": "Shell command that must exit 0 for build to run; skip with warning on failure.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "CSharpConfig": {
      "properties": {
        "exclude_functions": {
          "default": [],
          "description": "Functions to exclude from C# binding generation (e.g., functions not present in the\nC FFI layer). Excluded functions are omitted from both NativeMethods.cs and the\nwrapper class.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "exclude_types": {
          "default": [],
          "description": "Types to exclude from C# binding generation.\n\nC# bindings call the generated C FFI through P/Invoke, so types excluded from\n`[crates.ffi].exclude_types` are also excluded automatically by the C# backend.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "extra_lint_paths": {
          "default": [],
          "description": "Extra paths to append to default lint commands (format, check, typecheck).\nIgnored when project_file is set.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "features": {
          "default": null,
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "namespace": {
          "type": [
            "string",
            "null"
          ]
        },
        "package_id": {
          "default": null,
          "description": "NuGet `<PackageId>` to publish under. When unset, falls back to `namespace`.\nUse this when the published artifact id must differ from the C# `RootNamespace` —\ne.g. when the unprefixed name is owned by a third party on nuget.org and\nyou publish under a vendor-prefixed id like `SampleCrateDev.<Lib>`.",
          "type": [
            "string",
            "null"
          ]
        },
        "project_file": {
          "default": null,
          "description": "Project file for C# (e.g., \"MyProject.csproj\", \"MySolution.sln\"). When set, default\nlint/build/test commands target this file instead of the output directory.",
          "type": [
            "string",
            "null"
          ]
        },
        "rename_fields": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Per-field name remapping for this language. Key is `TypeName.field_name`, value is the\ndesired binding field name. Applied after automatic keyword escaping.",
          "type": "object"
        },
        "run_wrapper": {
          "default": null,
          "description": "Prefix wrapper for default tool invocations. When set, prepends this string to default\ncommands across all pipelines (lint, test, build, etc.).",
          "type": [
            "string",
            "null"
          ]
        },
        "serde_rename_all": {
          "default": null,
          "description": "Override the serde rename_all strategy for JSON field names (e.g. \"camelCase\", \"snake_case\").\nWhen set, this takes priority over the IR type-level serde_rename_all.",
          "type": [
            "string",
            "null"
          ]
        },
        "target_framework": {
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "CallConfig": {
      "description": "Configuration for the function call in each test.",
      "properties": {
        "args": {
          "default": [],
          "description": "How fixture `input` fields map to function arguments.",
          "items": {
            "$ref": "#/$defs/ArgMapping"
          },
          "type": "array"
        },
        "assertion_recipes": {
          "default": [],
          "description": "Assertion recipes enabled for all fixtures routed to this call.\n\nRecipes intentionally gate domain-shaped assertion shortcuts such as\n`embeddings_*`, `keywords`, tree parser helpers, and streaming\npseudo-fields. Generic recursive field/text/JSON assertions do not\nrequire a recipe.",
          "items": {
            "type": "string"
          },
          "type": "array",
          "uniqueItems": true
        },
        "async": {
          "default": false,
          "description": "Whether the function is async.",
          "type": "boolean"
        },
        "fields": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Per-call override for `[e2e].fields` alias map.\n\nWhen non-empty, replaces (not merges with) the global `fields` map for\nfixtures routed to this call.",
          "type": "object"
        },
        "fields_array": {
          "default": [],
          "description": "Per-call override for `[e2e].fields_array`.",
          "items": {
            "type": "string"
          },
          "type": "array",
          "uniqueItems": true
        },
        "fields_c_types": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Per-call override for `[e2e].fields_c_types`.",
          "type": "object"
        },
        "fields_enum": {
          "default": [],
          "description": "Per-call override for `[e2e].fields_enum`.",
          "items": {
            "type": "string"
          },
          "type": "array",
          "uniqueItems": true
        },
        "fields_method_calls": {
          "default": [],
          "description": "Per-call override for `[e2e].fields_method_calls`.",
          "items": {
            "type": "string"
          },
          "type": "array",
          "uniqueItems": true
        },
        "fields_optional": {
          "default": [],
          "description": "Per-call override for `[e2e].fields_optional`.",
          "items": {
            "type": "string"
          },
          "type": "array",
          "uniqueItems": true
        },
        "function": {
          "default": "",
          "description": "The function name (alef applies language naming conventions).",
          "type": "string"
        },
        "method": {
          "default": null,
          "description": "HTTP method for mock server routing (default: `\"POST\"`).\n\nUsed together with `path` when building `MockRoute` entries.",
          "type": [
            "string",
            "null"
          ]
        },
        "module": {
          "default": "",
          "description": "The module/package where the function lives.",
          "type": "string"
        },
        "options_type": {
          "default": null,
          "description": "Call-level constructor type for `json_object` config args.\n\nThis is the type of the function's config parameter (e.g. `EmbeddingConfig`\nvs `ExtractionConfig`) and is therefore identical across every binding — set\nit on the call, not in per-language overrides. Per-language overrides\n(`[e2e.calls.<name>.overrides.<lang>].options_type`) still take precedence\nwhen a binding exposes a language-specific wrapper type (e.g. `JsExtractionConfig`).",
          "type": [
            "string",
            "null"
          ]
        },
        "overrides": {
          "additionalProperties": {
            "$ref": "#/$defs/CallOverride"
          },
          "default": {},
          "description": "Per-language overrides for module/function/etc.",
          "type": "object"
        },
        "path": {
          "default": null,
          "description": "HTTP endpoint path for mock server routing (e.g., `\"/v1/chat/completions\"`).\n\nRequired when fixtures use `mock_response`. The Rust e2e generator uses\nthis to build the `MockRoute` that the mock server matches against.",
          "type": [
            "string",
            "null"
          ]
        },
        "result_element_is_string": {
          "default": false,
          "description": "When `true` (combined with `result_is_simple` + `result_is_array`),\nsignals that the result is `Vec<String>` returned to the host as a\nnative string array (e.g., Swift `[String]`) rather than an opaque\n`RustVec<RustString>` requiring `.asStr().toString()` per element.\n\nGenerators that emit per-element coercion for opaque RustVec types\n(currently Swift) drop the coercion and operate on the elements as\nnative strings when this flag is set.",
          "type": "boolean"
        },
        "result_fields": {
          "default": [],
          "description": "Per-call override for `result_fields`.\n\nWhen non-empty, this set replaces the global `[e2e].result_fields` for\nfixtures routed to this call.  Use this when different API functions return\ndifferently-shaped structs so each call can gate its own field set.\n\nExample:\n```toml\n[e2e.calls.crawl]\nresult_fields = [\"pages\", \"final_url\", \"stayed_on_domain\"]\n```",
          "items": {
            "type": "string"
          },
          "type": "array",
          "uniqueItems": true
        },
        "result_is_array": {
          "default": false,
          "description": "When `true` (combined with `result_is_simple`), the simple return is a\nslice/array (e.g., `Vec<String>` → `string[]` in TS).",
          "type": "boolean"
        },
        "result_is_bytes": {
          "default": false,
          "description": "When `true`, the function returns a raw byte array (`Vec<u8>` →\n`Uint8Array` / `[]byte` / `byte[]`).",
          "type": "boolean"
        },
        "result_is_option": {
          "default": false,
          "description": "When `true`, the function returns `Option<T>`.",
          "type": "boolean"
        },
        "result_is_simple": {
          "default": false,
          "description": "When `true`, the function returns a primitive (e.g. `String`, `bool`,\n`i32`) rather than a struct.  Generators that would otherwise emit\n`result.<field>` will fall back to the bare result variable.\n\nThis is a property of the Rust core's return type and therefore identical\nacross every binding — set it on the call, not in per-language overrides.\nThe same flag is also accepted under `[e2e.calls.<name>.overrides.<lang>]`\nfor backwards compatibility, but the call-level value takes precedence.",
          "type": "boolean"
        },
        "result_is_vec": {
          "default": false,
          "description": "When `true`, the function returns `Vec<T>` / `Array<T>`.  Generators that\nsupport per-element field assertions (rust, csharp) iterate or index into\nthe result; the typescript codegen indexes `[0]` to mirror csharp.\n\nAs with `result_is_simple`, this is a Rust-side property — set it on the\ncall, not on per-language overrides. Per-language overrides remain\nsupported for backwards compatibility.",
          "type": "boolean"
        },
        "result_var": {
          "default": "result",
          "description": "Variable name for the return value (default: \"result\").",
          "type": "string"
        },
        "returns_result": {
          "default": false,
          "description": "Whether the function returns `Result<T, E>` in its native binding.\nDefaults to `true`. When `false`, generators that distinguish Result-returning\nfrom non-Result-returning calls (currently Rust) will skip the\n`.expect(\"should succeed\")` unwrap and bind the raw return value directly.",
          "type": "boolean"
        },
        "returns_void": {
          "default": false,
          "description": "Whether the function returns only an error/unit — i.e., `Result<(), E>`.\n\nWhen combined with `returns_result = true`, Go generators emit `err := func()`\n(single return value) rather than `_, err := func()` (two return values).\nThis is needed for functions like `validate_host` that return only `error` in Go.",
          "type": "boolean"
        },
        "select_when": {
          "anyOf": [
            {
              "$ref": "#/$defs/SelectWhen"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Automatic fixture-routing condition.\n\nWhen set, a fixture whose `call` field is `None` is routed to this named call config\nif the condition is satisfied.  This avoids the need to tag every fixture with\n`\"call\": \"batch_scrape\"` when the fixture shape already identifies the call.\n\nExample (`alef.toml`):\n```toml\n[e2e.calls.batch_scrape]\nselect_when = { input_has = \"batch_urls\" }\n```"
        },
        "skip_languages": {
          "default": [],
          "description": "skip_languages",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "streaming": {
          "anyOf": [
            {
              "$ref": "#/$defs/StreamingConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Three-valued opt-in/out for streaming-virtual-field auto-detection.\n\n- `Some(true)`: force streaming semantics regardless of fixture shape.\n- `Some(false)`: disable streaming auto-detection — assertions referencing\n  neutral stream fields like `stream.items` / `stream.items.length` are\n  treated as plain field accessors on the result, not streaming adapters.\n- `None` (default): auto-detect — treat as streaming when either the\n  fixture provides a streaming `mock_response` or any assertion references\n  a neutral streaming-virtual-field name."
        },
        "unsupported_in": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Per-backend exclusion: backends listed here will emit a skip comment instead of\na failing test, with the documented reason that the call is unsupported on that\nbackend (e.g., \"brew: interact requires complex JSON serialization of PageAction enums\").\n\nUse this when a backend structurally cannot support a call (e.g., CLI-based\nbackends that lack certain features). Unlike `skip_languages`, unsupported calls\nare documented in the generated test files with rationale comments.\n\nExample:\n```toml\n[e2e.calls.interact]\nunsupported_in = { brew = \"interact requires serializing Vec<PageAction> enums to JSON CLI args\" }\n```",
          "type": "object"
        }
      },
      "type": "object"
    },
    "CallOverride": {
      "description": "Per-language override for function call configuration.",
      "properties": {
        "alias": {
          "default": null,
          "description": "Import alias (Go only, e.g., `htmd`).",
          "type": [
            "string",
            "null"
          ]
        },
        "arg_name_map": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Maps canonical argument names to language-specific argument names.\n\nUsed when a language binding uses a different parameter name than the\ncanonical `args` list in `CallConfig`. For example, if the canonical\narg name is `doc` but the Python binding uses `html`, specify:\n\n```toml\n[e2e.call.overrides.python]\narg_name_map = { doc = \"html\" }\n```\n\nThe key is the canonical name (from `args[].name`) and the value is the\nname to use when emitting the keyword argument in generated tests.",
          "type": "object"
        },
        "arg_order": {
          "default": [],
          "description": "Override the argument order for this language binding.\n\nLists argument names from `args` in the order they should be passed\nto the target function. Useful when a language binding reorders parameters\nrelative to the canonical `args` list in `CallConfig`.\n\nE.g., if `args = [path, mime_type, config]` but the Node.js binding\ntakes `(path, config, mime_type?)`, specify:\n```toml\n[e2e.call.overrides.node]\narg_order = [\"path\", \"config\", \"mime_type\"]\n```",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "assert_enum_fields": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Maps result-type field names to their enum type names for assertion routing.\nPer-call so e.g. `BatchObject.status` (enum) and `ResponseObject.status` (string)\ncan be disambiguated.",
          "type": "object"
        },
        "assertion_recipes": {
          "default": [],
          "description": "Assertion recipes enabled only for this language.",
          "items": {
            "type": "string"
          },
          "type": "array",
          "uniqueItems": true
        },
        "async": {
          "default": null,
          "description": "Override whether the call is async for this language.\n\nWhen set, takes precedence over the call-level `async` flag.\nUseful when a language binding uses a different async model — for example,\na Python binding that returns a sync iterator from a function marked\n`async = true` at the call level.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "bigint_fields": {
          "default": [],
          "description": "Fields on the options object that require `BigInt()` wrapping (WASM only).\n\n`wasm_bindgen` maps Rust `u64`/`i64` to JavaScript `BigInt`. Numeric\nvalues assigned to these setters must be wrapped with `BigInt(n)`.\n\nList camelCase field names, e.g.:\n```toml\n[e2e.call.overrides.wasm]\nbigint_fields = [\"maxTokens\", \"seed\"]\n```",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "c_engine_factory": {
          "default": null,
          "description": "C FFI engine factory pattern (C only).\n\nWhen set, the C generator wraps each test call in a\n`{prefix}_create_engine(config)` / `{prefix}_crawl_engine_handle_free(engine)`\nprologue/epilogue using the named config type as the \"arg 0\" handle type.\n\nThe value is the PascalCase config type name (without prefix), e.g.\n`\"CrawlConfig\"`. The generator will emit:\n```c\nKCRAWLCrawlConfig* config_handle = kcrawl_crawl_config_from_json(\"{json}\");\nKCRAWLCrawlEngineHandle* engine = kcrawl_create_engine(config_handle);\nkcrawl_crawl_config_free(config_handle);\nKCRAWLScrapeResult* result = kcrawl_scrape(engine, url);\n// ... assertions ...\nkcrawl_scrape_result_free(result);\nkcrawl_crawl_engine_handle_free(engine);\n```",
          "type": [
            "string",
            "null"
          ]
        },
        "c_free_fn": {
          "default": null,
          "description": "Free function for raw `char*` C results (C only).\n\nDefaults to `{prefix}_free_string` when unset and `raw_c_result_type == \"char*\"`.",
          "type": [
            "string",
            "null"
          ]
        },
        "class": {
          "default": null,
          "description": "Override the class name (Java/C# only).",
          "type": [
            "string",
            "null"
          ]
        },
        "cli_args": {
          "default": [],
          "description": "Static CLI arguments appended to every invocation (brew/CLI generator only).\n\nE.g., `[\"--format\", \"json\"]` appends `--format json` to every CLI call.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "cli_flags": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Maps fixture config field names to CLI flag names (brew/CLI generator only).\n\nE.g., `{\"output_format\": \"--format\"}` generates `--format <value>` from\nthe fixture's `output_format` input field.",
          "type": "object"
        },
        "client_factory": {
          "default": null,
          "description": "Client factory function name for instance-method languages (WASM, etc.).\n\nWhen set, the generated test imports this function, creates a client,\nand calls API methods on the instance instead of as top-level functions.\n\nE.g., `\"createClient\"` generates:\n```typescript\nimport { createClient } from 'pkg';\nconst client = createClient('test-key');\nconst result = await client.chat(request);\n```",
          "type": [
            "string",
            "null"
          ]
        },
        "client_factory_trailing_args": {
          "default": [],
          "description": "Verbatim trailing arguments appended after the fixed `(\"test-key\", ...)` pair\nwhen calling the `client_factory` function.\n\nUse this when the factory function takes additional positional parameters\nbeyond the API key and optional base URL that the generator would otherwise\nemit.  Each element is emitted verbatim, separated by `, `.\n\nExample — Gleam `create_client` takes five positional arguments:\n`(api_key, base_url, timeout_secs, max_retries, model_hint)`.  Set:\n```toml\n[e2e.call.overrides.gleam]\nclient_factory = \"create_client\"\nclient_factory_trailing_args = [\"option.None\", \"option.None\", \"option.None\"]\n```\nto produce `create_client(\"test-key\", option.Some(url), option.None, option.None, option.None)`.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "crate_name": {
          "default": null,
          "description": "Override the crate name (Rust only).",
          "type": [
            "string",
            "null"
          ]
        },
        "enum_fields": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Maps fixture option field names to their enum type names.\nE.g., `{\"headingStyle\": \"HeadingStyle\", \"codeBlockStyle\": \"CodeBlockStyle\"}`.\nThe generator imports these types and maps string values to enum constants.",
          "type": "object"
        },
        "enum_module": {
          "default": null,
          "description": "Module to import enum types from (if different from the main module).\nE.g., \"sample_markdown._sample_markdown\" for PyO3 native enums.",
          "type": [
            "string",
            "null"
          ]
        },
        "extra_args": {
          "default": [],
          "description": "Trailing positional arguments appended verbatim after the configured\n`args`. Used when the target function takes additional positional slots\n(e.g. visitor) the fixture cannot supply directly. (Rust generator only.)",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "from_json_module": {
          "default": null,
          "description": "Module to import `options_type` from when `options_via = \"from_json\"`.\n\nWhen set, a separate `from {from_json_module} import {options_type}` line\nis emitted instead of including the type in the main module import.\nE.g., `\"sample_llm._internal_bindings\"` for PyO3 native types.",
          "type": [
            "string",
            "null"
          ]
        },
        "function": {
          "default": null,
          "description": "Override the function name.",
          "type": [
            "string",
            "null"
          ]
        },
        "handle_atom_list_fields": {
          "default": [],
          "description": "Handle config fields whose list values are Elixir atoms (Rustler NifUnitEnum).\n\nWhen a config field is a `Vec<EnumType>` in Rust, the Elixir side must pass\na list of atoms (e.g., `[:image, :document]`) not strings (`[\"image\"]`).\nList the field names here so the generator emits atom literals instead of strings.\n\nE.g., `[\"asset_types\"]` generates `asset_types: [:image]` instead of `[\"image\"]`.",
          "items": {
            "type": "string"
          },
          "type": "array",
          "uniqueItems": true
        },
        "handle_config_type": {
          "default": null,
          "description": "WASM config class name for handle args (WASM generator only).\n\nWhen set, handle args are constructed using `ConfigType.default()` + setters\ninstead of passing a plain JS object (which fails `_assertClass` validation).\n\nE.g., `\"WasmCrawlConfig\"` generates:\n```js\nconst engineConfig = WasmCrawlConfig.default();\nengineConfig.maxDepth = 1;\nconst engine = createEngine(engineConfig);\n```",
          "type": [
            "string",
            "null"
          ]
        },
        "handle_dict_types": {
          "default": [],
          "description": "Handle config fields whose type constructor takes a single dict argument\ninstead of keyword arguments.\n\nE.g., `[\"auth\"]` means `AuthConfig({\"type\": \"basic\", ...})` instead of\n`AuthConfig(type=\"basic\", ...)`.",
          "items": {
            "type": "string"
          },
          "type": "array",
          "uniqueItems": true
        },
        "handle_nested_types": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Maps handle config field names to their Python type constructor names.\n\nWhen the handle config object contains a nested dict-valued field, the\ngenerator will wrap it in the specified type using keyword arguments.\nE.g., `{\"browser\": \"BrowserConfig\"}` generates `BrowserConfig(mode=\"auto\")`\ninstead of `{\"mode\": \"auto\"}`.",
          "type": "object"
        },
        "handle_struct_type": {
          "default": null,
          "description": "Elixir struct module name for the handle config argument.\n\nWhen set, the generated Elixir handle config uses struct literal syntax\n(`%Module.StructType{key: val}`) instead of a plain string-keyed map.\nRustler `NifStruct` requires a proper Elixir struct — plain maps are rejected.\n\nE.g., `\"CrawlConfig\"` generates `%SampleCrawler.CrawlConfig{download_assets: true}`.",
          "type": [
            "string",
            "null"
          ]
        },
        "header": {
          "default": null,
          "description": "C header file name (C only).",
          "type": [
            "string",
            "null"
          ]
        },
        "module": {
          "default": null,
          "description": "Override the module/import path.",
          "type": [
            "string",
            "null"
          ]
        },
        "nested_types": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Maps nested fixture object field names to their C# type names.\nUsed to generate `JsonSerializer.Deserialize<NestedType>(...)` for nested objects.\nE.g., `{\"preprocessing\": \"PreprocessingOptions\"}`.",
          "type": "object"
        },
        "nested_types_optional": {
          "default": true,
          "description": "When `false`, nested config builder results are passed directly to builder methods\nwithout wrapping in `Optional.of(...)`. Set to `false` for bindings where nested\noption types are non-optional (e.g., sample-markdown Java).\nDefaults to `true` for backward compatibility.",
          "type": "boolean"
        },
        "options_ptr": {
          "default": false,
          "description": "When `true`, `json_object` args with an `options_type` are passed as a\npointer (`*OptionsType`) rather than a value.  Use for Go bindings where\nthe options parameter is `*ConversionOptions` (nil-able pointer) rather\nthan a plain struct.\n\nAbsent options are passed as `nil`; present options are unmarshalled into\na local variable and passed as `&optionsVar`.",
          "type": "boolean"
        },
        "options_type": {
          "default": null,
          "description": "For json_object args: the constructor to use instead of raw dict/object.\nE.g., \"ConversionOptions\" — generates `ConversionOptions(**options)` in Python,\n`new ConversionOptions(options)` in TypeScript.",
          "type": [
            "string",
            "null"
          ]
        },
        "options_via": {
          "default": null,
          "description": "How to pass json_object args: \"kwargs\" (default), \"dict\", \"json\", or \"from_json\".\n\n- `\"kwargs\"`: construct `OptionsType(key=val, ...)` (requires `options_type`).\n- `\"dict\"`: pass as a plain dict/object literal `{\"key\": \"val\"}`.\n- `\"json\"`: pass via `json.loads('...')` / `JSON.parse('...')`.\n- `\"from_json\"`: call `OptionsType.from_json('...')` (Python only, PyO3 native types).",
          "type": [
            "string",
            "null"
          ]
        },
        "path_fields": {
          "default": [],
          "description": "Fields in a `json_object` arg that must be wrapped in `java.nio.file.Path.of()`\n(Java generator only).\n\nE.g., `[\"cache_dir\"]` wraps the string value of `cache_dir` so the builder\nreceives `java.nio.file.Path.of(\"/tmp/dir\")` instead of a plain string.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "php_client_factory": {
          "default": null,
          "description": "PHP client factory method name (PHP generator only).\n\nWhen set, the generated PHP test instantiates a client via\n`ClassName::factory_method('test-key')` and calls methods on the instance\ninstead of using static facade calls.\n\nE.g., `\"createClient\"` generates:\n```php\n$client = SampleLlm::createClient('test-key');\n$result = $client->chat($request);\n```",
          "type": [
            "string",
            "null"
          ]
        },
        "prefix": {
          "default": null,
          "description": "FFI symbol prefix (C only).",
          "type": [
            "string",
            "null"
          ]
        },
        "raw_c_result_type": {
          "default": null,
          "description": "Raw C return type, used verbatim instead of `{PREFIX}Type*` (C only).\n\nValid values: `\"char*\"`, `\"int32_t\"`, `\"uintptr_t\"`.\nWhen set, the C generator skips options handle construction and uses the\nraw type directly. Free logic is adjusted accordingly.",
          "type": [
            "string",
            "null"
          ]
        },
        "result_element_is_string": {
          "default": false,
          "description": "Per-language override mirroring `CallConfig.result_element_is_string`.\n\nSet this on a per-language override when only one host's binding exposes\nthe result as a native string array; otherwise prefer the call-level flag.",
          "type": "boolean"
        },
        "result_enum_fields": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Maps result field paths to their wasm-bindgen enum class names.\n\nwasm-bindgen exposes Rust enums as numeric discriminants in JavaScript\n(`WasmFinishReason.Stop === 0`), not string variants. When an `equals`\nassertion targets a field listed here, the WASM generator emits\n`expect(result.choices[0].finishReason).toBe(WasmFinishReason.Stop)`\ninstead of attempting `(value ?? \"\").trim()`.\n\nThe fixture's expected string value is converted to PascalCase to look\nup the variant (e.g. `\"tool_calls\"` -> `ToolCalls`).\n\nExample:\n```toml\n[e2e.calls.chat.overrides.wasm]\nresult_enum_fields = { \"choices[0].finish_reason\" = \"WasmFinishReason\", \"status\" = \"WasmBatchStatus\" }\n```",
          "type": "object"
        },
        "result_field_accessor": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Maps array-typed result fields to the method name on each element that\nyields a string used in `contains` / `contains_all` assertions.\n\nUsed when the array element is an opaque struct (e.g., a swift-bridge\n`type X;` declaration) and the element's \"name\" accessor is not the\ndefault `as_str` — for instance, `StructureItem` exposes `kind() -> String`\ninstead of `as_str()`. The codegen consults this map when emitting\n`.map { $0.<accessor>().toString() }` so the closure compiles.\n\nExample:\n```toml\n[e2e.call.overrides.swift]\nresult_field_accessor = { \"structure\" = \"kind\" }\n```",
          "type": "object"
        },
        "result_is_array": {
          "default": false,
          "description": "When `true` (and combined with `result_is_simple`), the simple result is\na slice/array type (e.g., `[]string` in Go, `Vec<String>` in Rust).\nThe Go generator uses `strings.Join(value, \" \")` for `contains` assertions\ninstead of `string(value)`.",
          "type": "boolean"
        },
        "result_is_bytes": {
          "default": false,
          "description": "When `true`, the function returns a raw byte array (e.g., `byte[]` in Java,\n`[]byte` in Go). Used by generators to select the correct length accessor\n(field `.length` vs method `.length()`).",
          "type": "boolean"
        },
        "result_is_json_struct": {
          "default": false,
          "description": "When `true`, the Zig generator treats the result as a `[]u8` JSON string\nrepresenting a struct value (e.g., `ExtractionResult` serialized via the\nFFI `_to_json` helper). The generator parses the JSON with\n`std.json.parseFromSlice(std.json.Value, ...)` before emitting field\nassertions, traversing the dynamic JSON object for each field path.\n(Zig generator only.)",
          "type": "boolean"
        },
        "result_is_option": {
          "default": false,
          "description": "When `true`, the function returns `Option<T>`. The result is unwrapped\nbefore any non-`is_none`/`is_some` assertion runs; `is_empty`/`not_empty`\nassertions map to `is_none()`/`is_some()`. (Rust generator.)",
          "type": "boolean"
        },
        "result_is_pointer": {
          "default": true,
          "description": "When `true`, indicates that the result is a pointer type (e.g., `*string` in Go,\n`*T` in Rust). The Go codegen will dereference it. When `false` (Go only), the\nresult is a value type and should not be dereferenced.\n\nUsed to distinguish between functions that return `(value, error)` where value\nis a scalar (string, uint, bool) as-is vs. those that return pointers.\nDefaults to `true` for backward compatibility with existing fixtures.",
          "type": "boolean"
        },
        "result_is_r_list": {
          "default": false,
          "description": "When `true`, the R generator emits the call result directly without wrapping\nin `jsonlite::fromJSON()`. Use when the R binding already returns a native\nR list (`Robj`) rather than a JSON string. Field-path assertions still use\n`result$field` accessor syntax (i.e. `result_is_simple` behaviour is NOT\nimplied — only the JSON parse wrapper is suppressed). (R generator only.)",
          "type": "boolean"
        },
        "result_is_simple": {
          "default": false,
          "description": "When `true`, the function returns a simple type (e.g., `String`) rather\nthan a struct.  Generators that would normally emit `result.content`\n(or equivalent field access) will use the result variable directly.",
          "type": "boolean"
        },
        "result_is_vec": {
          "default": false,
          "description": "When `true`, the function returns `Vec<T>` rather than a single value.\nField-path assertions are emitted as `.iter().all(|r| <accessor>)` so\nevery element is checked. (Rust generator.)",
          "type": "boolean"
        },
        "result_type": {
          "default": null,
          "description": "C FFI opaque result type name (C only).\n\nThe PascalCase name of the result struct, without the prefix.\nE.g., `\"ChatCompletionResponse\"` for `SamplellmChatCompletionResponse*`.\nIf not set, defaults to the function name in PascalCase.",
          "type": [
            "string",
            "null"
          ]
        },
        "returns_result": {
          "default": null,
          "description": "Per-rust override of the call-level `returns_result`. When set, takes\nprecedence over `CallConfig.returns_result` for the Rust generator only.\nUseful when one binding is fallible while others are not.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "trait_imports": {
          "default": [],
          "description": "Rust trait names to import when `client_factory` is set (Rust generator only).\n\nWhen `client_factory` is set, the generated test creates a client object and\ncalls methods on it. Those methods are defined on traits (e.g. `LlmClient`,\n`FileClient`) that must be in scope. List the trait names here and the Rust\ngenerator will emit `use {module}::{trait_name};` for each.\n\nE.g.:\n```toml\n[e2e.call.overrides.rust]\nclient_factory = \"create_client\"\ntrait_imports = [\"LlmClient\", \"FileClient\", \"BatchClient\", \"ResponseClient\"]\n```",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "unnamed_arg_indices": {
          "default": [],
          "description": "Argument indices (0-based) that should be passed without labels in Swift\n(i.e., using `(_` parameter syntax instead of `name:`).\n\nSwift allows unnamed first parameters: `func f(_ x: Int)` vs `func f(x: Int)`.\nWhen the generated test call should match this signature, list the indices here.\n\nE.g., `[0]` for a single unnamed first parameter:\n```toml\n[e2e.call.overrides.swift]\nunnamed_arg_indices = [0]\n```\ngenerates `f(contentVec)` instead of `f(content: contentVec)`.",
          "items": {
            "format": "uint",
            "minimum": 0,
            "type": "integer"
          },
          "type": "array"
        },
        "visitor_function": {
          "default": null,
          "description": "Alternative function name to use when the fixture includes a `visitor`.\n\nSome bindings expose two entry points: `Convert(html, opts)` for the\nplain case and `ConvertWithVisitor(html, opts, visitor)` when a visitor\nis involved.  Set this to the visitor-accepting function name so the\ngenerator can pick the right symbol automatically.\n\nE.g., `\"ConvertWithVisitor\"` makes the Go generator emit:\n```go\nresult, err := htmd.ConvertWithVisitor(html, nil, visitor)\n```\ninstead of `htmd.Convert(html, nil, visitor)` (which would not compile).",
          "type": [
            "string",
            "null"
          ]
        },
        "visitor_trait": {
          "default": null,
          "description": "Trait name for the visitor pattern (Rust e2e tests only).\n\nWhen a fixture declares a `visitor` block, the Rust e2e generator emits\n`impl <trait_name> for _TestVisitor { ... }` and imports the trait from\n`{module}::visitor`. When unset, no visitor block is emitted and fixtures\nthat declare a visitor will cause a codegen error.\n\nE.g., `\"HtmlVisitor\"` generates:\n```rust,ignore\nuse sample_markdown_rs::visitor::{HtmlVisitor, NodeContext, VisitResult};\n// ...\nimpl HtmlVisitor for _TestVisitor { ... }\n```",
          "type": [
            "string",
            "null"
          ]
        },
        "wrap_options_in_some": {
          "default": false,
          "description": "When `true`, the Rust generator wraps the `json_object` argument expression\nin `Some(...).clone()` to match an owned `Option<T>` parameter slot rather\nthan passing `&options`. (Rust generator only.)",
          "type": "boolean"
        }
      },
      "type": "object"
    },
    "CapsuleTypeConfig": {
      "anyOf": [
        {
          "description": "Capsule round-trip: the Rust type exposes `into_raw()` returning a raw pointer.\nThe generated code calls `PyCapsule_New(value.into_raw(), capsule_name, None)` on return,\nand `PyCapsule_GetPointer` + `from_raw()` on input.\n\nValue is the fully-qualified Python capsule name (e.g. `\"sample_language.Language\"`).",
          "type": "string"
        },
        {
          "description": "Python-side construction: the type does not have a direct `into_raw()`.\nInstead, the generated code constructs the Python type by calling a Python factory\n(e.g. `sample_language.Parser(language)`) where `language` is a bound capsule argument.",
          "properties": {
            "construct_from": {
              "description": "The capsule-type argument name to pass to the Python constructor.\nMust be one of the other capsule-type entries (e.g. `\"Language\"`).",
              "type": "string"
            },
            "python_type": {
              "description": "The fully-qualified Python type to import and call (e.g. `\"sample_language.Parser\"`).",
              "type": "string"
            }
          },
          "required": [
            "python_type",
            "construct_from"
          ],
          "type": "object"
        }
      ],
      "description": "Configuration for a single capsule type entry in `PythonConfig::capsule_types`.\n\nSupports two TOML forms via `#[serde(untagged)]`:\n\n- String: `Language = \"sample_language.Language\"` → capsule round-trip via `into_raw()`\n- Struct: `Parser = { python_type = \"sample_language.Parser\", construct_from = \"Language\" }` → Python-side construction"
    },
    "CitationAuthor": {
      "additionalProperties": false,
      "description": "A single author entry in a `CITATION.cff` file. Per the Citation File Format\nschema, each entry is either a person (uses `family_names` + `given_names`)\nor a legal entity (uses `name`). Validation lives in the renderer rather\nthan in serde because the choice is mutually exclusive.",
      "properties": {
        "email": {
          "default": null,
          "description": "Optional contact email (applies to either person or entity).",
          "type": [
            "string",
            "null"
          ]
        },
        "family_names": {
          "default": null,
          "description": "Person author: family name(s).",
          "type": [
            "string",
            "null"
          ]
        },
        "given_names": {
          "default": null,
          "description": "Person author: given name(s).",
          "type": [
            "string",
            "null"
          ]
        },
        "name": {
          "default": null,
          "description": "Entity author: organisation or legal-entity name.",
          "type": [
            "string",
            "null"
          ]
        },
        "orcid": {
          "default": null,
          "description": "Optional ORCID iD URL (`https://orcid.org/0000-0000-0000-0000`).",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "CitationConfig": {
      "additionalProperties": false,
      "description": "Configuration for the alef-generated `CITATION.cff` file at the repo root.\n\nWhen this section is present in `alef.toml`, `alef sync-versions` writes a\nfully-rendered Citation File Format YAML using these fields plus the current\nworkspace version (read from `Cargo.toml`). When absent, alef falls back to\nupdating the `version:` line of a hand-authored CITATION.cff in place.\n\nAll field names follow Rust convention; the renderer emits the canonical\nCFF kebab-case keys (`cff-version`, `repository-code`, `date-released`,\n`family-names`, `given-names`).",
      "properties": {
        "abstract": {
          "description": "One-paragraph summary (`abstract:`). Required.",
          "type": "string"
        },
        "authors": {
          "description": "Authors list — at least one entry required. Persons and legal entities\ncan be mixed (e.g. `Na'aman Hirschfeld` + `SampleCrate, Inc.`).",
          "items": {
            "$ref": "#/$defs/CitationAuthor"
          },
          "type": "array"
        },
        "date-released": {
          "default": null,
          "description": "Release date in `YYYY-MM-DD` form (`date-released:`). Optional.",
          "type": [
            "string",
            "null"
          ]
        },
        "doi": {
          "default": null,
          "description": "Persistent DOI for the cited release (`doi:`). Optional.",
          "type": [
            "string",
            "null"
          ]
        },
        "license": {
          "default": null,
          "description": "SPDX license identifier (`license:`). When omitted, the renderer falls\nback to `Cargo.toml [workspace.package].license`.",
          "type": [
            "string",
            "null"
          ]
        },
        "message": {
          "default": "If you use this software, please cite it using the metadata below.",
          "description": "Canonical citation message shown to consumers (`message:`).",
          "type": "string"
        },
        "repository-code": {
          "description": "Source-code repository URL (`repository-code:`). Required.",
          "type": "string"
        },
        "title": {
          "description": "Software title (`title:`). Required.",
          "type": "string"
        },
        "url": {
          "default": null,
          "description": "Project landing-page URL (`url:`). Optional.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "required": [
        "title",
        "abstract",
        "authors",
        "repository-code"
      ],
      "type": "object"
    },
    "CleanConfig": {
      "properties": {
        "before": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ],
          "description": "Command(s) to run before the main clean commands; aborts on failure."
        },
        "clean": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ],
          "description": "Command(s) to clean build artifacts for this language."
        },
        "precondition": {
          "description": "Shell command that must exit 0 for clean to run; skip with warning on failure.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "ClientConstructorConfig": {
      "description": "Custom constructor configuration for an opaque handle type.\n\nWhen present under `[workspace.client_constructors.<TypeName>]`, every\nbackend that wraps the type in an opaque handle emits a constructor whose\nbody is the `body` template string with `{type_name}` and `{source_path}`\nsubstituted.",
      "properties": {
        "body": {
          "description": "Body template.  Use `{type_name}` for the bare type name and\n`{source_path}` for the fully-qualified core path.",
          "type": "string"
        },
        "error_type": {
          "default": null,
          "description": "Error type returned by the constructor (`Result<Self, ErrType>`).\nDefaults to `String` when absent.",
          "type": [
            "string",
            "null"
          ]
        },
        "params": {
          "default": [],
          "description": "Ordered list of constructor parameters.",
          "items": {
            "$ref": "#/$defs/ConstructorParam"
          },
          "type": "array"
        }
      },
      "required": [
        "body"
      ],
      "type": "object"
    },
    "ConstructorParam": {
      "description": "One parameter in a [`ClientConstructorConfig`].",
      "properties": {
        "name": {
          "description": "Parameter name as it appears in the generated function signature.",
          "type": "string"
        },
        "type": {
          "description": "Rust type of the parameter (e.g. `\"*const c_char\"` for FFI, `\"&str\"` for Rust-embedded).",
          "type": "string"
        }
      },
      "required": [
        "name",
        "type"
      ],
      "type": "object"
    },
    "CsharpDtoStyle": {
      "enum": [
        "record"
      ],
      "type": "string"
    },
    "CustomModulesConfig": {
      "description": "Custom modules that alef should declare (mod X;) but not generate.\nThese are hand-written modules imported by the generated lib.rs.",
      "properties": {
        "csharp": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "elixir": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "ffi": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "go": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "java": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "node": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "php": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "python": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "r": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "ruby": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "wasm": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        }
      },
      "type": "object"
    },
    "CustomRegistration": {
      "description": "Custom classes/functions from hand-written modules to register in module init.",
      "properties": {
        "classes": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "functions": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "init_calls": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        }
      },
      "type": "object"
    },
    "CustomRegistrationsConfig": {
      "description": "Per-language custom registrations.",
      "properties": {
        "elixir": {
          "anyOf": [
            {
              "$ref": "#/$defs/CustomRegistration"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "node": {
          "anyOf": [
            {
              "$ref": "#/$defs/CustomRegistration"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "php": {
          "anyOf": [
            {
              "$ref": "#/$defs/CustomRegistration"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "python": {
          "anyOf": [
            {
              "$ref": "#/$defs/CustomRegistration"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "ruby": {
          "anyOf": [
            {
              "$ref": "#/$defs/CustomRegistration"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "wasm": {
          "anyOf": [
            {
              "$ref": "#/$defs/CustomRegistration"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        }
      },
      "type": "object"
    },
    "DartConfig": {
      "properties": {
        "core_crate_override": {
          "default": null,
          "description": "Override the core Cargo dependency name and path for the Dart binding crate.\nWhen set, the binding `Cargo.toml` depends on this crate (resolved as\n`../../../crates/<override>`) instead of the umbrella `[crate.name]`.\nDefaults to unset.",
          "type": [
            "string",
            "null"
          ]
        },
        "exclude_extra_dependencies": {
          "default": [],
          "description": "Keys to subtract from the merged `extra_dependencies` set for this\nlanguage only.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "exclude_functions": {
          "default": [],
          "description": "Functions to exclude from Dart binding generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "exclude_types": {
          "default": [],
          "description": "Types to exclude from Dart binding generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "extra_dependencies": {
          "additionalProperties": true,
          "default": {},
          "description": "Additional Cargo dependencies for the generated Dart Rust bridge crate.",
          "type": "object"
        },
        "extra_lint_paths": {
          "default": [],
          "description": "Extra paths to append to default lint commands.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "features": {
          "default": null,
          "description": "Cargo features to enable on the binding crate.",
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "frb_version": {
          "default": null,
          "description": "flutter_rust_bridge version to pin in generated pubspec.yaml.\nDefaults to `template_versions::cargo::FLUTTER_RUST_BRIDGE` when unset.",
          "type": [
            "string",
            "null"
          ]
        },
        "lib_name": {
          "default": null,
          "description": "Dart library name (the `library` declaration). Defaults to the pubspec name.",
          "type": [
            "string",
            "null"
          ]
        },
        "package_name": {
          "default": null,
          "description": "Dart package name override (e.g. for pub.dev scoped packages).",
          "type": [
            "string",
            "null"
          ]
        },
        "pubspec_name": {
          "default": null,
          "description": "Dart pub.dev package name (e.g. `\"my_package\"`). Used as the `name` in\n`pubspec.yaml`. Defaults to a snake_case derivation of the crate name.",
          "type": [
            "string",
            "null"
          ]
        },
        "rename_fields": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Per-field name remapping. Key is `TypeName.field_name`, value is the\ndesired binding field name. Applied after automatic keyword escaping.",
          "type": "object"
        },
        "run_wrapper": {
          "default": null,
          "description": "Prefix wrapper for default tool invocations.",
          "type": [
            "string",
            "null"
          ]
        },
        "serde_rename_all": {
          "default": null,
          "description": "Override the serde rename_all strategy for JSON field names (e.g. \"camelCase\", \"snake_case\").",
          "type": [
            "string",
            "null"
          ]
        },
        "skip_frb": {
          "default": false,
          "description": "Skip the `flutter_rust_bridge_codegen generate` post-build step.\n\nWhen `true`, alef omits the `RunCommand` that invokes\n`flutter_rust_bridge_codegen` during `alef all` / `alef generate`.\nFile post-processors (sealed-variant rewriting, loader injection, etc.)\nare still executed; only the upstream codegen invocation is suppressed.\n\nUse this when `flutter_rust_bridge` is not installed on the host —\ne.g. in CI environments that regen binding scaffolding only, or on\ndeveloper machines that have not installed the Flutter SDK.\n\nEquivalent CLI override: pass `--skip-frb` to `alef all` or\n`alef generate`, or set `ALEF_SKIP_COMMANDS=flutter_rust_bridge_codegen`.\n\nDefault: `false` (FRB codegen runs as usual).",
          "type": "boolean"
        },
        "stub_methods": {
          "default": [],
          "description": "Method names whose Rust bridge body should be emitted as `unimplemented!()`.\n\nUse this when a function's FFI signature (e.g. nested tuples containing\n`Vec<u8>`) cannot be represented across the FRB bridge at all. Consumers must\nlist the method names explicitly — this field has no built-in defaults so the\nknob is library-agnostic.\n\nExample (`alef.toml`):\n```toml\n[crates.dart]\nstub_methods = [\"batch_extract_bytes\", \"batch_extract_bytes_sync\"]\n```",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "style": {
          "$ref": "#/$defs/DartStyle",
          "default": "frb",
          "description": "Bridging style. `\"frb\"` (default) uses flutter_rust_bridge; `\"ffi\"` emits\nraw `dart:ffi` source over the cbindgen C library."
        },
        "target_dep_overrides": {
          "default": [],
          "description": "Per-target Cargo dependency overrides for the binding crate.\n\nWhen set, the emitted `Cargo.toml` wraps the base core dependency in a\n`[target.'cfg(not(<cfg>))'.dependencies]` section and adds a matching\n`[target.'cfg(<cfg>)'.dependencies]` block using `override_features`\n(and `default_features = false` when `override_default_features = false`).\nRequired when the binding has to swap the feature set on a specific\ntarget triple, e.g. Android x86_64 dropping ORT-dependent features.\n\nExample (`alef.toml`):\n```toml\n[[crates.dart.target_dep_overrides]]\ncfg = \"all(target_os = \\\"android\\\", target_arch = \\\"x86_64\\\")\"\nfeatures = [\"android-target\"]\ndefault_features = false\n```",
          "items": {
            "$ref": "#/$defs/DartTargetDepOverride"
          },
          "type": "array"
        }
      },
      "type": "object"
    },
    "DartStyle": {
      "description": "Dart bridging style: FRB (default) or raw `dart:ffi`.",
      "oneOf": [
        {
          "const": "frb",
          "description": "flutter_rust_bridge — emits a Rust crate plus Dart wrappers using\nFRB-generated bridge symbols. Default.",
          "type": "string"
        },
        {
          "const": "ffi",
          "description": "Raw `dart:ffi` over the cbindgen C ABI — emits Dart-only source that\nloads the shared library at runtime. Cheaper to ship; loses FRB's\nasync ergonomics and freezed-style data classes.",
          "type": "string"
        }
      ]
    },
    "DartTargetDepOverride": {
      "properties": {
        "cfg": {
          "description": "Cargo `cfg(...)` predicate (without the `cfg(...)` wrapper). Example:\n`all(target_os = \"android\", target_arch = \"x86_64\")`.",
          "type": "string"
        },
        "default_features": {
          "default": false,
          "description": "When false (default), emit `default-features = false` for this target.\nWhen true, allow the core dep's default features through.",
          "type": "boolean"
        },
        "features": {
          "default": [],
          "description": "Features to enable on the core dependency for this target.",
          "items": {
            "type": "string"
          },
          "type": "array"
        }
      },
      "required": [
        "cfg"
      ],
      "type": "object"
    },
    "DtoConfig": {
      "description": "Per-language DTO/type generation style configuration.\n\nControls what type system is used for generated public API types in each language\n(e.g., Python `@dataclass` vs `TypedDict` vs `pydantic.BaseModel`).",
      "properties": {
        "csharp": {
          "$ref": "#/$defs/CsharpDtoStyle",
          "default": "record",
          "description": "C# type style (default: record)."
        },
        "elixir": {
          "$ref": "#/$defs/ElixirDtoStyle",
          "default": "struct",
          "description": "Elixir type style (default: struct)."
        },
        "go": {
          "$ref": "#/$defs/GoDtoStyle",
          "default": "struct",
          "description": "Go type style (default: struct)."
        },
        "java": {
          "$ref": "#/$defs/JavaDtoStyle",
          "default": "record",
          "description": "Java type style (default: record)."
        },
        "node": {
          "$ref": "#/$defs/NodeDtoStyle",
          "default": "interface",
          "description": "TypeScript/Node type style (default: interface)."
        },
        "php": {
          "$ref": "#/$defs/PhpDtoStyle",
          "default": "readonly-class",
          "description": "PHP type style (default: readonly-class)."
        },
        "python": {
          "$ref": "#/$defs/PythonDtoStyle",
          "default": "dataclass",
          "description": "Python input type style (default: dataclass)."
        },
        "python_output": {
          "anyOf": [
            {
              "$ref": "#/$defs/PythonDtoStyle"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Python output/return type style (default: same as `python`)."
        },
        "r": {
          "$ref": "#/$defs/RDtoStyle",
          "default": "list",
          "description": "R type style (default: list)."
        },
        "ruby": {
          "$ref": "#/$defs/RubyDtoStyle",
          "default": "struct",
          "description": "Ruby type style (default: struct)."
        }
      },
      "type": "object"
    },
    "E2eConfig": {
      "description": "Root e2e configuration from `[e2e]` section of alef.toml.",
      "properties": {
        "call": {
          "$ref": "#/$defs/CallConfig",
          "description": "Default function call configuration."
        },
        "calls": {
          "additionalProperties": {
            "$ref": "#/$defs/CallConfig"
          },
          "default": {},
          "description": "Named additional call configurations for multi-function testing.\nFixtures reference these via the `call` field, e.g. `\"call\": \"embed\"`.",
          "type": "object"
        },
        "exclude_categories": {
          "default": [],
          "description": "Fixture categories excluded from cross-language e2e codegen.\n\nFixtures whose resolved category matches an entry in this set are\nskipped by every per-language e2e generator — no test is emitted at\nall (no skip directive, no commented-out body). The fixture files stay\non disk and remain available to Rust integration tests inside the\nconsumer crate's own `tests/` directory.\n\nUse this to keep fixtures that exercise internal middleware (cache,\nproxy, budget, hooks, etc.) out of bindings whose public surface does\nnot expose those layers.\n\nExample:\n```toml\n[e2e]\nexclude_categories = [\"cache\", \"proxy\", \"budget\", \"hooks\"]\n```",
          "items": {
            "type": "string"
          },
          "type": "array",
          "uniqueItems": true
        },
        "fields": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Field path aliases: maps fixture field paths to actual API struct paths.\nE.g., \"metadata.title\" -> \"metadata.document.title\"\nSupports struct access (`foo.bar`), map access (`foo[key]`), direct fields.",
          "type": "object"
        },
        "fields_array": {
          "default": [],
          "description": "Fields that are arrays/Vecs on the result type.\nWhen a fixture path like `json_ld.name` traverses an array field, the\naccessor adds `[0]` (or language equivalent) to index into the first element.",
          "items": {
            "type": "string"
          },
          "type": "array",
          "uniqueItems": true
        },
        "fields_c_types": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "C FFI accessor type chain: maps `\"{parent_snake_type}.{field}\"` to the\nPascalCase return type name (without prefix).\n\nUsed by the C e2e generator to emit chained FFI accessor calls for\nnested field paths. The root type is always `conversion_result`.\n\nExample:\n```toml\n[e2e.fields_c_types]\n\"conversion_result.metadata\" = \"HtmlMetadata\"\n\"html_metadata.document\" = \"DocumentMetadata\"\n```",
          "type": "object"
        },
        "fields_enum": {
          "default": [],
          "description": "Fields whose resolved type is an enum in the generated bindings.\n\nWhen a `contains` / `contains_all` / etc. assertion targets one of these\nfields, language generators that cannot call `.contains()` directly on an\nenum (e.g., Java) will emit a string-conversion call first.  For Java,\nthe generated assertion calls `.getValue()` on the enum — the `@JsonValue`\nmethod that all alef-generated Java enums expose — to obtain the lowercase\nserde string before performing the string comparison.\n\nBoth the raw fixture field path (before alias resolution) and the resolved\npath (after alias resolution via `[e2e.fields]`) are accepted, so you can\nuse either form:\n\n```toml\n# Raw fixture field:\nfields_enum = [\"links[].link_type\", \"assets[].category\"]\n# …or the resolved (aliased) field name:\nfields_enum = [\"links[].link_type\", \"assets[].asset_category\"]\n```",
          "items": {
            "type": "string"
          },
          "type": "array",
          "uniqueItems": true
        },
        "fields_method_calls": {
          "default": [],
          "description": "Fields where the accessor is a method call (appends `()`) rather than a field access.\nRust-specific: Java always uses `()`, Python/PHP use field access.\nListed as the full resolved field path (after alias resolution).\nE.g., `\"metadata.format.excel\"` means `.excel` should be emitted as `.excel()`.",
          "items": {
            "type": "string"
          },
          "type": "array",
          "uniqueItems": true
        },
        "fields_optional": {
          "default": [],
          "description": "Fields that are Optional/nullable in the return type.\nRust generators use .as_deref().unwrap_or(\"\") for strings, .is_some() for structs.",
          "items": {
            "type": "string"
          },
          "type": "array",
          "uniqueItems": true
        },
        "fixtures": {
          "default": "fixtures",
          "description": "Directory containing fixture JSON files (default: \"fixtures\").",
          "type": "string"
        },
        "format": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Per-language formatter commands.",
          "type": "object"
        },
        "harness": {
          "$ref": "#/$defs/HarnessConfig",
          "default": {
            "app_class": null,
            "body_schema_setter": null,
            "host": "127.0.0.1",
            "imports": [],
            "method_enum": null,
            "overrides": {},
            "port": 8000,
            "register_method": null,
            "response_body_field": "body",
            "route_builder": null,
            "run_method": null
          },
          "description": "Server-shaped e2e harness configuration for HTTP fixtures.\nKnobs for code generation that spawn the SUT app and register handlers."
        },
        "harness_extras": {
          "additionalProperties": {
            "$ref": "#/$defs/ManifestExtras"
          },
          "default": {},
          "description": "Per-language extra dependencies to splice into the e2e harness's\nlanguage-native manifest (`e2e/<lang>/package.json` for node/wasm,\n`e2e/python/pyproject.toml` for Python, etc.). Distinct from the\nRust-binding `extra_dependencies` knob — this one targets the\nhost-language test-harness manifest. Keys are canonical language\nnames (`node`, `wasm`, `python`, …).",
          "type": "object"
        },
        "languages": {
          "default": [],
          "description": "Languages to generate e2e tests for. Defaults to top-level `languages` list.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "output": {
          "default": "e2e",
          "description": "Output directory for generated e2e test projects (default: \"e2e\").",
          "type": "string"
        },
        "packages": {
          "additionalProperties": {
            "$ref": "#/$defs/PackageRef"
          },
          "default": {},
          "description": "Per-language package reference overrides.",
          "type": "object"
        },
        "registry": {
          "$ref": "#/$defs/RegistryConfig",
          "default": {
            "categories": [],
            "github_repo": null,
            "output": "test_apps",
            "packages": {},
            "run": {}
          },
          "description": "Registry-mode configuration from `[e2e.registry]`."
        },
        "result_fields": {
          "default": [],
          "description": "Known top-level fields on the result type.\n\nWhen non-empty, assertions whose resolved field path starts with a\nsegment that is NOT in this set are emitted as comments (skipped)\ninstead of executable assertions.  This prevents broken assertions\nwhen fixtures reference fields from a different operation (e.g.,\n`batch.completed_count` on a `ScrapeResult`).",
          "items": {
            "type": "string"
          },
          "type": "array",
          "uniqueItems": true
        },
        "test_documents_dir": {
          "default": "test_documents",
          "description": "Repo-root-relative directory holding binary file fixtures referenced by\n`file_path` / `bytes` fixture args (default: \"test_documents\").\n\nBackends that emit chdir / setup hooks for file-based fixtures resolve\nthe relative path from the test-emission directory via\n[`E2eConfig::test_documents_relative_from`]. The default matches the\nsample_core convention; downstream crates whose fixtures don't reference\nfiles (e.g. sample-llm, which uses pure mock-server fixtures) can leave\nthe default in place — backends conditionally emit the setup only when\nfixtures actually need it.",
          "type": "string"
        }
      },
      "required": [
        "call"
      ],
      "type": "object"
    },
    "ElixirConfig": {
      "properties": {
        "app_name": {
          "type": [
            "string",
            "null"
          ]
        },
        "cpu_bound_functions": {
          "default": [],
          "description": "Functions that should be scheduled on the dirty CPU scheduler.\nHTML parsing and other CPU-intensive NIFs should be listed here to avoid\nblocking BEAM scheduler threads.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "exclude_functions": {
          "default": [],
          "description": "Functions to exclude from Elixir NIF generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "exclude_types": {
          "default": [],
          "description": "Types to exclude from Elixir NIF generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "extra_dependencies": {
          "additionalProperties": true,
          "default": {},
          "description": "Additional Cargo dependencies for this language's binding crate only.",
          "type": "object"
        },
        "extra_lint_paths": {
          "default": [],
          "description": "Extra paths to append to default lint commands (format, check, typecheck).",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "features": {
          "default": null,
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "nif_targets": {
          "default": [],
          "description": "Rust target triples for which precompiled NIFs are uploaded to the\nGitHub release. `RustlerPrecompiled` reads this list to know which\narchives to download at install time. Must agree with the consumer's\nCI build matrix and the `generate-elixir-checksums` action's targets\ninput. When empty, falls back to the historical default of\n`aarch64-apple-darwin, aarch64-unknown-linux-gnu, x86_64-unknown-linux-gnu, x86_64-pc-windows-gnu`.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "rename_fields": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Per-field name remapping for this language. Key is `TypeName.field_name`, value is the\ndesired binding field name. Applied after automatic keyword escaping.",
          "type": "object"
        },
        "run_wrapper": {
          "default": null,
          "description": "Prefix wrapper for default tool invocations. When set, prepends this string to default\ncommands across all pipelines (lint, test, build, etc.).",
          "type": [
            "string",
            "null"
          ]
        },
        "scaffold_output": {
          "default": null,
          "description": "Override the scaffold output directory for this language's Cargo.toml and package files.",
          "type": [
            "string",
            "null"
          ]
        },
        "serde_rename_all": {
          "default": null,
          "description": "Override the serde rename_all strategy for JSON field names (e.g. \"camelCase\", \"snake_case\").\nWhen set, this takes priority over the IR type-level serde_rename_all.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "ElixirDtoStyle": {
      "enum": [
        "struct",
        "typed-struct"
      ],
      "type": "string"
    },
    "EntrypointSpec": {
      "description": "Per-entrypoint configuration inside a `[[crates.services]]` table.\n\n```toml\n[[crates.services.entrypoints]]\nmethod = \"run\"\nkind = \"run\"\n\n[[crates.services.entrypoints]]\nmethod = \"into_router\"\nkind = \"finalize\"\n```",
      "properties": {
        "kind": {
          "description": "`\"run\"` for a long-lived async entrypoint; `\"finalize\"` for a consuming\ntransform.  Checked at validation time.",
          "type": "string"
        },
        "method": {
          "description": "Name of the method on the owner type (e.g. `\"run\"`, `\"into_router\"`).",
          "type": "string"
        }
      },
      "required": [
        "method",
        "kind"
      ],
      "type": "object"
    },
    "ExcludeConfig": {
      "properties": {
        "functions": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "methods": {
          "default": [],
          "description": "Exclude specific methods: \"TypeName.method_name\"",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "types": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        }
      },
      "type": "object"
    },
    "ExtraDepSpec": {
      "anyOf": [
        {
          "description": "Simple `\"name\" = \"version\"` form.",
          "type": "string"
        },
        {
          "additionalProperties": true,
          "description": "Detailed `\"name\" = { … }` form.",
          "type": "object"
        }
      ],
      "description": "A single extra-dependency declaration. Accepts either a bare version string\n(`\"tree-sitter\" = \"^0.25.0\"`) or a free-form TOML table for source/feature\nmetadata (`\"foo\" = { version = \"1\", git = \"https://…\" }`).\n\nPer-language emitters decide which table keys they understand. Unknown keys\nare surfaced as warnings but never block emission — the goal is forward\ncompatibility as the alef.toml surface grows."
    },
    "FfiConfig": {
      "properties": {
        "error_style": {
          "default": "last_error",
          "type": "string"
        },
        "exclude_functions": {
          "default": [],
          "description": "Functions to exclude from FFI binding generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "exclude_types": {
          "default": [],
          "description": "Types to exclude from FFI binding generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "features": {
          "default": null,
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "header_name": {
          "type": [
            "string",
            "null"
          ]
        },
        "lib_name": {
          "default": null,
          "description": "Native library name for Go cgo/Java Panama/C# P/Invoke (e.g., \"sample_pack_ffi\").\nDefaults to `{prefix}_ffi`.",
          "type": [
            "string",
            "null"
          ]
        },
        "plugin_error_constructor": {
          "default": null,
          "description": "Rust expression used to construct an error value of this crate's\n`error_type` from a runtime `String` message inside generated FFI\ntrait-bridge plugin shims (`plugin_impl_initialize`, `plugin_impl_shutdown`).\n\nThe expression has access to a local variable `msg: String` containing\nthe underlying error message and is interpolated verbatim. Example\nvalues:\n\n```toml\n# downstream whose error type has a struct variant with two fields:\nplugin_error_constructor = \"\"\"\nsample_core::SampleCrateError::Plugin { message: msg, plugin_name: String::new() }\n\"\"\"\n\n# downstream whose error type implements `From<String>`:\nplugin_error_constructor = \"MyError::from(msg)\"\n```\n\nDefaults to `None`. When unset, the plugin shim still emits — backends\nfall back to a `format!(\"{}: {}\", prefix, msg)`-style construction via\nthe configured `error_constructor`. Downstreams that don't expose\ntrait-bridged plugins can ignore this knob entirely.",
          "type": [
            "string",
            "null"
          ]
        },
        "prefix": {
          "type": [
            "string",
            "null"
          ]
        },
        "rename_fields": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Per-field name remapping for this language. Key is `TypeName.field_name`, value is the\ndesired binding field name. Applied after automatic keyword escaping.",
          "type": "object"
        },
        "serde_rename_all": {
          "default": null,
          "description": "Override the serde rename_all strategy for JSON field names (e.g. \"camelCase\", \"snake_case\").\nWhen set, this takes priority over the IR type-level serde_rename_all.",
          "type": [
            "string",
            "null"
          ]
        },
        "target_dep_overrides": {
          "default": [],
          "description": "Per-target overrides for the core-crate dependency emitted into the\ngenerated FFI Cargo.toml. Used when some `cfg(...)` target requires a\nreduced feature set (e.g. the `x86_64-linux-android` emulator cannot\nlink ONNX Runtime, so sample_core ships an `android-target` feature\nflag that drops every ORT-dependent extractor).\n\nWhen this list is non-empty the scaffold emits\n`[target.'cfg(not(<any-cfg>))'.dependencies]` for the default branch\nplus one `[target.'cfg(<cfg>)'.dependencies]` block per override,\ninstead of the unconditional `[dependencies]` block.",
          "items": {
            "$ref": "#/$defs/FfiTargetDepOverride"
          },
          "type": "array"
        },
        "visitor_callbacks": {
          "default": false,
          "description": "If true, generate visitor/callback FFI support.",
          "type": "boolean"
        }
      },
      "type": "object"
    },
    "FfiTargetDepOverride": {
      "description": "A per-target replacement for the core-crate feature set emitted into the\ngenerated FFI Cargo.toml. See [`FfiConfig::target_dep_overrides`].",
      "properties": {
        "cfg": {
          "description": "Cargo cfg expression, without the surrounding `cfg(...)`.\nExample: `all(target_os = \"android\", target_arch = \"x86_64\")`.",
          "type": "string"
        },
        "features": {
          "default": [],
          "description": "Replacement feature set used for the core-crate dependency when this\ntarget matches. An empty list means \"no features\".",
          "items": {
            "type": "string"
          },
          "type": "array"
        }
      },
      "required": [
        "cfg"
      ],
      "type": "object"
    },
    "FormatConfig": {
      "description": "Post-generation formatting configuration.\nAfter code generation, alef can automatically run language-native formatters\non the emitted package directories to ensure CI formatter checks pass.",
      "properties": {
        "command": {
          "default": null,
          "description": "Optional custom command override. If set, this command is run instead\nof the language's default formatter. Must be a shell command string\n(e.g., \"prettier --write .\").",
          "type": [
            "string",
            "null"
          ]
        },
        "enabled": {
          "default": true,
          "description": "Enable post-generation formatting (default: true).\nSet to false to skip formatting for all languages, or use per-language\noverrides in `[format.<lang>]` to disable specific formatters.",
          "type": "boolean"
        }
      },
      "type": "object"
    },
    "GenerateConfig": {
      "description": "Controls which generation passes alef runs.\nAll flags default to `true`; set to `false` to skip a pass.\nCan be overridden per-language via `[generate_overrides.<lang>]`.",
      "properties": {
        "async_wrappers": {
          "default": true,
          "description": "Generate async/sync function pairs with runtime management (default: true)",
          "type": "boolean"
        },
        "bindings": {
          "default": true,
          "description": "Generate low-level struct wrappers, From impls, module init (default: true)",
          "type": "boolean"
        },
        "configs": {
          "default": true,
          "description": "Generate config builder constructors from Default types (default: true)",
          "type": "boolean"
        },
        "errors": {
          "default": true,
          "description": "Generate error type hierarchies from thiserror enums (default: true)",
          "type": "boolean"
        },
        "package_metadata": {
          "default": true,
          "description": "Generate package manifests (pyproject.toml, package.json, etc.) (default: true)",
          "type": "boolean"
        },
        "public_api": {
          "default": true,
          "description": "Generate idiomatic public API wrappers (default: true)",
          "type": "boolean"
        },
        "reverse_conversions": {
          "default": true,
          "description": "Generate `From<BindingType> for CoreType` reverse conversions (default: true).\nSet to false when the binding layer only returns core types and never accepts them.",
          "type": "boolean"
        },
        "type_conversions": {
          "default": true,
          "description": "Generate recursive type marshaling helpers (default: true)",
          "type": "boolean"
        }
      },
      "type": "object"
    },
    "GeneratedHeaderConfig": {
      "properties": {
        "issues_url": {
          "default": null,
          "description": "URL shown in generated-file headers for issue reporting and docs.",
          "type": [
            "string",
            "null"
          ]
        },
        "regenerate_command": {
          "default": null,
          "description": "Regeneration command shown in generated-file headers.",
          "type": [
            "string",
            "null"
          ]
        },
        "verify_command": {
          "default": null,
          "description": "Freshness verification command shown in generated-file headers.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "GleamConfig": {
      "properties": {
        "app_name": {
          "type": [
            "string",
            "null"
          ]
        },
        "element_constructors": {
          "default": [],
          "description": "Per-`element_type` Gleam record-constructor recipes used by the e2e\ngenerator when emitting `json_object` arg literals. Each entry maps a\nfixture-side `element_type` string (e.g. `\"BatchFileItem\"`) to a\nstructured constructor description that the codegen interpolates per\nJSON-array item. Without an entry the codegen falls back to the\n`json_object_wrapper` (or a plain `json_to_gleam`).\n\nExample:\n\n```toml\n[[crates.gleam.element_constructors]]\nelement_type = \"BatchFileItem\"\nconstructor = \"sample_core.BatchFileItem\"\n[[crates.gleam.element_constructors.fields]]\ngleam_field = \"path\"\nkind = \"file_path\"\njson_field = \"path\"\n[[crates.gleam.element_constructors.fields]]\ngleam_field = \"config\"\nkind = \"literal\"\nvalue = \"option.None\"\n```",
          "items": {
            "$ref": "#/$defs/GleamElementConstructor"
          },
          "type": "array"
        },
        "exclude_functions": {
          "default": [],
          "description": "Functions to exclude from Gleam binding generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "exclude_types": {
          "default": [],
          "description": "Types to exclude from Gleam binding generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "extra_lint_paths": {
          "default": [],
          "description": "Extra paths to append to default lint commands.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "features": {
          "default": null,
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "json_object_wrapper": {
          "default": null,
          "description": "Optional Gleam expression template used to wrap `json_object` arg\nvalues when no `element_type` recipe matches. The placeholder\n`{json}` is replaced with a Gleam string literal containing the JSON\nform of the arg value, allowing the downstream's Gleam binding to do\nits own parsing.\n\nExample:\n\n```toml\n[crates.gleam]\njson_object_wrapper = \"sample_core.config_from_json_string({json})\"\n```\n\nWhen `None`, the codegen emits `{json}` verbatim (a plain Gleam\nstring), matching the iter15 default.",
          "type": [
            "string",
            "null"
          ]
        },
        "nif_module": {
          "default": null,
          "description": "Erlang atom name for @external(erlang, \"<nif>\", ...) lookups (e.g., \"my_app_nif\").\nDefaults to the app_name.",
          "type": [
            "string",
            "null"
          ]
        },
        "rename_fields": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Per-field name remapping for this language. Key is `TypeName.field_name`, value is the\ndesired binding field name. Applied after automatic keyword escaping.",
          "type": "object"
        },
        "run_wrapper": {
          "default": null,
          "description": "Prefix wrapper for default tool invocations.",
          "type": [
            "string",
            "null"
          ]
        },
        "serde_rename_all": {
          "default": null,
          "description": "Override the serde rename_all strategy for JSON field names (e.g. \"camelCase\", \"snake_case\").\nWhen set, this takes priority over the IR type-level serde_rename_all.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "GleamElementConstructor": {
      "description": "One per-`element_type` Gleam record-constructor recipe. Keyed by the\nfixture-side `element_type` string and consumed by the e2e Gleam codegen\nwhen building `json_object` arg literals.",
      "properties": {
        "constructor": {
          "description": "Fully-qualified Gleam constructor identifier (e.g.\n`\"sample_core.BatchFileItem\"`). Emitted verbatim before the `(...)` field\nlist.",
          "type": "string"
        },
        "element_type": {
          "description": "Fixture-side `element_type` value this recipe applies to (e.g.\n`\"BatchFileItem\"`).",
          "type": "string"
        },
        "fields": {
          "description": "Ordered list of fields to emit inside the constructor's `(...)` block,\nin argument-position order. Each field describes how its value is\nderived from the per-item JSON object.",
          "items": {
            "$ref": "#/$defs/GleamElementField"
          },
          "type": "array"
        }
      },
      "required": [
        "element_type",
        "constructor",
        "fields"
      ],
      "type": "object"
    },
    "GleamElementField": {
      "description": "One field inside a [`GleamElementConstructor`]'s argument list.\n\n`kind` selects the source/encoding strategy:\n* `\"file_path\"` — read `json_field` from the JSON object as a string,\n  prefix with the configured `test_documents_dir` when the value does not\n  start with `/`, and emit as a Gleam string literal.\n* `\"byte_array\"` — read `json_field` from the JSON object as a JSON\n  `Array(Number)` and emit as a Gleam BitArray literal `<<n1, n2, …>>`.\n* `\"string\"` — read `json_field` as a string, emit as a Gleam string\n  literal; falls back to `default` (or empty) if missing.\n* `\"literal\"` — emit `value` verbatim (no JSON lookup). Use for\n  constant fields like `config: option.None`.",
      "properties": {
        "default": {
          "default": null,
          "description": "Default Gleam expression when `json_field` is missing/null. Only\nhonoured by the `\"string\"` strategy today.",
          "type": [
            "string",
            "null"
          ]
        },
        "gleam_field": {
          "description": "Gleam record field name (e.g. `\"path\"`, `\"config\"`).",
          "type": "string"
        },
        "json_field": {
          "default": null,
          "description": "JSON object key to read, when `kind` is one of the JSON-driven\nstrategies. Required for `\"file_path\"`, `\"byte_array\"`, `\"string\"`;\nignored for `\"literal\"`.",
          "type": [
            "string",
            "null"
          ]
        },
        "kind": {
          "description": "Source/encoding strategy. See struct doc.",
          "type": "string"
        },
        "value": {
          "default": null,
          "description": "Verbatim Gleam expression to emit when `kind = \"literal\"`.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "required": [
        "gleam_field",
        "kind"
      ],
      "type": "object"
    },
    "GoConfig": {
      "properties": {
        "exclude_types": {
          "default": [],
          "description": "Types to exclude from Go binding generation.\n\nGo bindings call the generated C FFI directly through cgo, so types excluded from\n`[crates.ffi].exclude_types` are also excluded automatically by the Go backend.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "extra_lint_paths": {
          "default": [],
          "description": "Extra paths to append to default lint commands (format, check, typecheck).",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "features": {
          "default": null,
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "functional_options": {
          "default": [],
          "description": "Struct types that should emit the functional-options pattern (`With<Field>` helpers\nplus `New<Struct>(opts ...<Struct>Option)` constructor).\nBy default, pure data DTOs emit plain struct literals; this allowlist enables the\nfunctional-options pattern only for behaviour-knob types (e.g., `DialOptions`).\nDefaults to empty (no functional-options emitted).",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "module": {
          "type": [
            "string",
            "null"
          ]
        },
        "package_name": {
          "description": "Override the Go package name (default: derived from module path)",
          "type": [
            "string",
            "null"
          ]
        },
        "rename_fields": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Per-field name remapping for this language. Key is `TypeName.field_name`, value is the\ndesired binding field name. Applied after automatic keyword escaping.",
          "type": "object"
        },
        "run_wrapper": {
          "default": null,
          "description": "Prefix wrapper for default tool invocations. When set, prepends this string to default\ncommands across all pipelines (lint, test, build, etc.).",
          "type": [
            "string",
            "null"
          ]
        },
        "serde_rename_all": {
          "default": null,
          "description": "Override the serde rename_all strategy for JSON field names (e.g. \"camelCase\", \"snake_case\").\nWhen set, this takes priority over the IR type-level serde_rename_all.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "GoDtoStyle": {
      "enum": [
        "struct"
      ],
      "type": "string"
    },
    "HandlerContractConfig": {
      "description": "Configuration for one handler-contract entry in `[[crates.handler_contracts]]`.\n\nThis augments a trait already present in the extracted surface with\nservice-specific metadata: the dispatch method that backends must bridge,\nwhether that method is async, and the names of the wire request/response DTOs.\n\n```toml\n[[crates.handler_contracts]]\ntrait_name = \"Handler\"\ndispatch_method = \"call\"\nis_async = true\nwire_request_type = \"RequestData\"\nwire_response_type = \"ResponseData\"\n```",
      "properties": {
        "dispatch_extra_params": {
          "default": [],
          "description": "Verbatim parameter declarations the generated bridge inserts *before* the wire\nrequest parameter and then ignores in the body. Used when the dispatch method\nhas leading parameters whose concrete types cannot be reconstructed from the\nsanitized surface (e.g. foreign framework types). Default: none.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "dispatch_method": {
          "description": "Name of the primary dispatch method (e.g. `\"call\"`).",
          "type": "string"
        },
        "dispatch_return_type": {
          "default": null,
          "description": "Verbatim return type for the generated dispatch future's `Output`. When absent,\nthe bridge synthesizes `Result<{wire_response}, Box<dyn Error + Send + Sync>>`.\nSet this when the trait's dispatch returns a library-specific type the bridge\nmust produce via [`Self::response_adapter`].",
          "type": [
            "string",
            "null"
          ]
        },
        "is_async": {
          "default": true,
          "description": "Whether the dispatch method is async (defaults to `true`).",
          "type": "boolean"
        },
        "optional_overrides": {
          "default": [],
          "description": "Methods that backends may optionally override (have default implementations\nin the trait).  Subset of the trait's method names.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "response_adapter": {
          "default": null,
          "description": "Path to a library function that converts the bridge's\n`Result<{wire_response}, Box<dyn Error + Send + Sync>>` outcome into the\n[`Self::dispatch_return_type`]. When absent, the bridge returns the wire response\ndirectly. The function is opaque to the generator — it simply emits a call to it.",
          "type": [
            "string",
            "null"
          ]
        },
        "trait_name": {
          "description": "Name of the Rust trait in the surface (e.g. `\"Handler\"`).",
          "type": "string"
        },
        "wire_param_name": {
          "default": null,
          "description": "Name of the wire request parameter in the generated dispatch signature.\nWhen absent, defaults to `\"request\"`.",
          "type": [
            "string",
            "null"
          ]
        },
        "wire_request_type": {
          "default": null,
          "description": "Name of the wire request DTO (e.g. `\"RequestData\"`).\nWhen absent, the dispatch method's signature is used verbatim.",
          "type": [
            "string",
            "null"
          ]
        },
        "wire_response_type": {
          "default": null,
          "description": "Name of the wire response DTO (e.g. `\"ResponseData\"`).\nWhen absent, the dispatch method's return type is used verbatim.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "required": [
        "trait_name",
        "dispatch_method"
      ],
      "type": "object"
    },
    "HarnessConfig": {
      "description": "Server-shaped e2e harness configuration for HTTP fixtures.\n\nWhen HTTP fixtures are present (server-pattern testing), alef generates\na harness script that starts the SUT app, registers handlers per fixture,\nand serves requests. This config provides the language-agnostic knobs that\ncontrol harness code generation.",
      "properties": {
        "app_class": {
          "default": null,
          "description": "SUT app class name (e.g., \"App\")",
          "type": [
            "string",
            "null"
          ]
        },
        "body_schema_setter": {
          "default": null,
          "description": "Method/field on RouteBuilder to set request body schema (e.g., \"request_schema_json\")",
          "type": [
            "string",
            "null"
          ]
        },
        "host": {
          "default": "127.0.0.1",
          "description": "Default host for SUT binding (e.g., \"127.0.0.1\")",
          "type": "string"
        },
        "imports": {
          "default": [],
          "description": "Module/package to import the SUT app from (e.g., \"my_app\")",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "method_enum": {
          "default": null,
          "description": "HTTP method enum/type name (e.g., \"Method\")",
          "type": [
            "string",
            "null"
          ]
        },
        "overrides": {
          "additionalProperties": {
            "$ref": "#/$defs/HarnessOverride"
          },
          "default": {},
          "description": "Per-language harness overrides",
          "type": "object"
        },
        "port": {
          "default": 8000,
          "description": "Default port for SUT binding (e.g., 8000)",
          "format": "uint16",
          "maximum": 65535,
          "minimum": 0,
          "type": "integer"
        },
        "register_method": {
          "default": null,
          "description": "Method to register handlers on the app (e.g., \"route\" or \"get\"/\"post\"/etc.)",
          "type": [
            "string",
            "null"
          ]
        },
        "response_body_field": {
          "default": "body",
          "description": "Field name in the handler's returned response object that carries the\nresponse body payload (e.g., \"body\" or \"content\"). Defaults to \"body\".\nConfigure to match the deserialization shape of the SUT's Response type.",
          "type": "string"
        },
        "route_builder": {
          "default": null,
          "description": "RouteBuilder class name (if distinct from return type of register_method)",
          "type": [
            "string",
            "null"
          ]
        },
        "run_method": {
          "default": null,
          "description": "Serve entrypoint method name (e.g., \"run\")",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "HarnessOverride": {
      "description": "Per-language harness config overrides.",
      "properties": {
        "app_class": {
          "default": null,
          "description": "SUT app class name (overrides HarnessConfig.app_class)",
          "type": [
            "string",
            "null"
          ]
        },
        "body_schema_setter": {
          "default": null,
          "description": "Method/field on RouteBuilder to set request body schema",
          "type": [
            "string",
            "null"
          ]
        },
        "imports": {
          "default": null,
          "description": "Modules/packages to import the SUT app from (overrides HarnessConfig.imports)",
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "method_enum": {
          "default": null,
          "description": "HTTP method enum/type name",
          "type": [
            "string",
            "null"
          ]
        },
        "register_method": {
          "default": null,
          "description": "Method to register handlers (overrides HarnessConfig.register_method)",
          "type": [
            "string",
            "null"
          ]
        },
        "run_method": {
          "default": null,
          "description": "Serve entrypoint method name (overrides HarnessConfig.run_method)",
          "type": [
            "string",
            "null"
          ]
        },
        "server_config_factory": {
          "default": null,
          "description": "Expression to instantiate the default ServerConfig (overrides HarnessConfig.server_config_factory)",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "HomebrewCliTest": {
      "description": "A single CLI test entry for the Homebrew test_app generator.\n\nEach entry describes one test step in `run_tests.sh`.  The `command`\nfield is a verbatim shell fragment; the following variables are already\nexported by `run_tests.sh` when the fragment is evaluated:\n\n- `$CLI_FORMULA` — the CLI binary name (from `cli_formula`)\n- `$VERSION` — the package version\n- `$TAP` — the Homebrew tap (e.g. `\"myorg/tap\"`)\n- `$SCRIPT_DIR` — absolute directory of `run_tests.sh`\n\nIf `expect_contains` is set the test passes only when the command's\ncombined stdout+stderr contains the given substring; otherwise a zero\nexit code is sufficient.\n\nExample `alef.toml`:\n\n```toml\n[[crates.e2e.registry.packages.homebrew.cli_tests]]\nname = \"version\"\ncommand = \"$CLI_FORMULA --version\"\nexpect_contains = \"$VERSION\"\n\n[[crates.e2e.registry.packages.homebrew.cli_tests]]\nname = \"convert-h1\"\ncommand = \"echo '<h1>Hi</h1>' | $CLI_FORMULA\"\nexpect_contains = \"# Hi\"\n```",
      "properties": {
        "command": {
          "description": "Shell fragment executed verbatim; variables `$CLI_FORMULA`, `$VERSION`,\n`$TAP`, and `$SCRIPT_DIR` are in scope.",
          "type": "string"
        },
        "expect_contains": {
          "default": null,
          "description": "Substring that must appear in the combined stdout+stderr output.\nWhen `None` a zero exit code is sufficient.",
          "type": [
            "string",
            "null"
          ]
        },
        "name": {
          "description": "Short identifier used in `PASS:` / `FAIL:` reporting.",
          "type": "string"
        }
      },
      "required": [
        "name",
        "command"
      ],
      "type": "object"
    },
    "IncludeConfig": {
      "properties": {
        "functions": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "types": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        }
      },
      "type": "object"
    },
    "JavaBuilderMode": {
      "oneOf": [
        {
          "const": "auto",
          "description": "Emit builder when field count >= 8 OR (nested type exists AND field count >= 5).",
          "type": "string"
        },
        {
          "const": "always",
          "description": "Always emit builder for types with defaults.",
          "type": "string"
        },
        {
          "const": "never",
          "description": "Never emit builder.",
          "type": "string"
        }
      ]
    },
    "JavaConfig": {
      "properties": {
        "artifact_id": {
          "default": null,
          "description": "Override the Maven `<artifactId>` emitted by alef-scaffold and alef-e2e. When\nunset, defaults to the crate name (the `[[crates]] name = \"...\"`). Set this when\nthe published artifactId differs from the source crate name (e.g. crate\n`sample-markdown-rs` published as `sample-markdown`).",
          "type": [
            "string",
            "null"
          ]
        },
        "dto": {
          "$ref": "#/$defs/JavaDtoConfig",
          "default": {
            "builder": "auto"
          },
          "description": "DTO-specific configuration (e.g., builder mode)."
        },
        "exclude_types": {
          "default": [],
          "description": "Types to exclude from Java binding generation.\n\nJava's Panama bindings call the generated C FFI directly, so types excluded from\n`[crates.ffi].exclude_types` are also excluded automatically by the Java backend.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "extra_lint_paths": {
          "default": [],
          "description": "Extra paths to append to default lint commands (format, check, typecheck).\nIgnored when project_file is set.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "features": {
          "default": null,
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "ffi_style": {
          "default": "panama",
          "type": "string"
        },
        "group_id": {
          "default": null,
          "description": "Override the Maven `<groupId>` emitted by alef-scaffold and alef-e2e. When unset,\n`java_group_id()` falls back to the Java `package` value. Set this when the\npublished Maven coords differ from the Java package path (e.g. group\n`dev.sample_core`, package `dev.sample_core.samplemarkdown`).",
          "type": [
            "string",
            "null"
          ]
        },
        "package": {
          "type": [
            "string",
            "null"
          ]
        },
        "project_file": {
          "default": null,
          "description": "Project file for Maven/Gradle (e.g., \"pom.xml\", \"build.gradle\"). When set, default\nlint/build/test commands target this file instead of the output directory.",
          "type": [
            "string",
            "null"
          ]
        },
        "rename_fields": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Per-field name remapping for this language. Key is `TypeName.field_name`, value is the\ndesired binding field name. Applied after automatic keyword escaping.",
          "type": "object"
        },
        "run_wrapper": {
          "default": null,
          "description": "Prefix wrapper for default tool invocations. When set, prepends this string to default\ncommands across all pipelines (lint, test, build, etc.).",
          "type": [
            "string",
            "null"
          ]
        },
        "serde_rename_all": {
          "default": null,
          "description": "Override the serde rename_all strategy for JSON field names (e.g. \"camelCase\", \"snake_case\").\nWhen set, this takes priority over the IR type-level serde_rename_all.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "JavaDtoConfig": {
      "description": "Java-specific DTO configuration.",
      "properties": {
        "builder": {
          "$ref": "#/$defs/JavaBuilderMode",
          "default": "auto",
          "description": "Builder mode: auto (default), always, or never."
        }
      },
      "type": "object"
    },
    "JavaDtoStyle": {
      "enum": [
        "record"
      ],
      "type": "string"
    },
    "JniConfig": {
      "description": "Configuration for the JNI Rust shim crate emitter (`alef-backend-jni`).\n\nMost identifiers are derived from the paired `[crates.kotlin_android]`\nsection (package, features, etc.).  Set `crate_dir` when the JNI crate\ndirectory should differ from the default `<config.name>-jni/` — for\nexample when `config.name` carries a language-specific suffix (e.g.\n`\"sample-markdown-rs\"`) but you want the JNI crate to live at\n`crates/sample-markdown-jni/` to match every other binding crate.",
      "properties": {
        "crate_dir": {
          "default": null,
          "description": "Override the JNI crate directory name.\n\nWhen set, the JNI crate is placed at `crates/<crate_dir>-jni/` and the\n`[package] name` in the generated `Cargo.toml` is `<crate_dir>-jni`.\nWhen unset, both derive from `config.name` (the default, which matches\nthe behavior used by `alef-backend-jni::gen_shims::jni_output_path`).",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "KotlinAndroidConfig": {
      "description": "Configuration for the dedicated Kotlin/Android backend (`alef-backend-kotlin-android`).\n\nDistinct from [`KotlinConfig`] (Kotlin/JVM). When a crate targets the\n`kotlin_android` language slug, this struct controls the emitted\n`build.gradle.kts`, `AndroidManifest.xml`, namespace, Maven publish\ncoordinates, ABI list, and the bundled Java facade emitted into\n`src/main/java/` so the AAR is self-contained.",
      "properties": {
        "abis": {
          "default": null,
          "description": "ABIs to scaffold under `src/main/jniLibs/<abi>/`. Defaults to\n`[\"arm64-v8a\", \"x86_64\"]`.",
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "artifact_id": {
          "default": null,
          "description": "Maven `artifactId` for the generated AAR. Defaults to `{crate}-android`.",
          "type": [
            "string",
            "null"
          ]
        },
        "compile_sdk": {
          "default": null,
          "description": "Android compile SDK level. Defaults to `template_versions::toolchain::ANDROID_COMPILE_SDK`.",
          "format": "uint32",
          "minimum": 0,
          "type": [
            "integer",
            "null"
          ]
        },
        "exclude_functions": {
          "default": [],
          "description": "Functions to exclude from generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "exclude_types": {
          "default": [],
          "description": "Types to exclude from generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "extra_lint_paths": {
          "default": [],
          "description": "Extra paths to append to default lint commands.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "features": {
          "default": null,
          "description": "Per-language feature override. When set, these features are used instead of\n`[crate] features` for this language's binding crate.",
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "group_id": {
          "default": null,
          "description": "Maven `groupId` for the generated AAR. No default — when unset the\nemitter falls back to `package`.",
          "type": [
            "string",
            "null"
          ]
        },
        "jvm_target": {
          "default": null,
          "description": "JVM bytecode target for Kotlin and Java compilation\n(e.g. `\"17\"`). Defaults to `template_versions::toolchain::ANDROID_JVM_TARGET`.",
          "type": [
            "string",
            "null"
          ]
        },
        "min_sdk": {
          "default": null,
          "description": "Android min SDK level. Defaults to `template_versions::toolchain::ANDROID_MIN_SDK`.",
          "format": "uint32",
          "minimum": 0,
          "type": [
            "integer",
            "null"
          ]
        },
        "namespace": {
          "default": null,
          "description": "Android library manifest `namespace`. Defaults to `package`.",
          "type": [
            "string",
            "null"
          ]
        },
        "package": {
          "default": null,
          "description": "JVM-style package for Kotlin bindings (e.g. `dev.sample_core`).\nDefaults to the crate name.",
          "type": [
            "string",
            "null"
          ]
        },
        "rename_fields": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Per-field name remapping for this language. Key is `TypeName.field_name`.",
          "type": "object"
        },
        "run_wrapper": {
          "default": null,
          "description": "Prefix wrapper for default tool invocations.",
          "type": [
            "string",
            "null"
          ]
        },
        "serde_rename_all": {
          "default": null,
          "description": "Override the serde rename_all strategy for JSON field names.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "KotlinConfig": {
      "properties": {
        "exclude_functions": {
          "default": [],
          "description": "Functions to exclude from Kotlin binding generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "exclude_types": {
          "default": [],
          "description": "Types to exclude from Kotlin binding generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "extra_lint_paths": {
          "default": [],
          "description": "Extra paths to append to default lint commands (format, check, typecheck).",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "features": {
          "default": null,
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "ffi_style": {
          "$ref": "#/$defs/KotlinFfiStyle",
          "default": "panama",
          "description": "FFI strategy. `\"panama\"` (default) consumes the Java/Panama FFM facade.\n`\"jni\"` emits a Kotlin Bridge object with `external fun` declarations\nand a `DefaultClient` class holding a `Long` handle. Android backend\nforces `\"jni\"` regardless of this setting."
        },
        "mode": {
          "default": null,
          "description": "Emission mode controlling which Kotlin project layout is generated.\n\nAccepted values:\n- `\"jvm\"` (default) — standard JVM-only project under `packages/kotlin/`\n- `\"kmp\"` — Kotlin Multiplatform project under `packages/kotlin-mpp/`\n- `\"android\"` — Android library project under `packages/kotlin-android/`\n\nWhen `None`, defaults to `\"jvm\"`.",
          "type": [
            "string",
            "null"
          ]
        },
        "package": {
          "type": [
            "string",
            "null"
          ]
        },
        "rename_fields": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Per-field name remapping for this language. Key is `TypeName.field_name`, value is the\ndesired binding field name. Applied after automatic keyword escaping.",
          "type": "object"
        },
        "run_wrapper": {
          "default": null,
          "description": "Prefix wrapper for default tool invocations. When set, prepends this string to default\ncommands across all pipelines (lint, test, build, etc.).",
          "type": [
            "string",
            "null"
          ]
        },
        "serde_rename_all": {
          "default": null,
          "description": "Override the serde rename_all strategy for JSON field names (e.g. \"camelCase\", \"snake_case\").\nWhen set, this takes priority over the IR type-level serde_rename_all.",
          "type": [
            "string",
            "null"
          ]
        },
        "target": {
          "$ref": "#/$defs/KotlinTarget",
          "default": "jvm",
          "description": "Target platform for Kotlin output. `\"jvm\"` (default) emits source consuming\nthe Java/Panama FFM facade; `\"native\"` emits Kotlin/Native source consuming\nthe cbindgen C FFI library. `\"multiplatform\"` emits KMP scaffolding."
        }
      },
      "type": "object"
    },
    "KotlinFfiStyle": {
      "description": "FFI strategy for Kotlin JVM / Android binding emission.\n\n- `\"panama\"` (default): consumes the Java/Panama FFM facade emitted by\n  `alef-backend-java`. Requires JDK 22+ at runtime. Not supported on\n  Android Runtime.\n- `\"jni\"`: emits a `object <Module>Bridge { external fun native<...>(...) }`\n  object with JNI declarations and a `DefaultClient` class holding a `Long`\n  handle. Compatible with Android Runtime (JDK 11). Consumers must ship a\n  `<crate>-jni` Rust crate exporting matching `Java_*` JNI symbols.",
      "enum": [
        "panama",
        "jni"
      ],
      "type": "string"
    },
    "KotlinTarget": {
      "description": "Target platform for Kotlin code generation.\n\n- `\"jvm\"` (default): emits source consuming the Java/Panama FFM facade.\n- `\"native\"`: emits Kotlin/Native source consuming the cbindgen C FFI library.\n- `\"multiplatform\"`: emits Kotlin Multiplatform project scaffolding.",
      "enum": [
        "jvm",
        "native",
        "multiplatform"
      ],
      "type": "string"
    },
    "Language": {
      "oneOf": [
        {
          "enum": [
            "python",
            "node",
            "ruby",
            "php",
            "elixir",
            "wasm",
            "ffi",
            "go",
            "java",
            "csharp",
            "r",
            "rust",
            "kotlin",
            "kotlin_android",
            "swift",
            "dart",
            "gleam",
            "zig"
          ],
          "type": "string"
        },
        {
          "const": "c",
          "description": "C consumer of the FFI layer — e2e test target, not a generated binding.",
          "type": "string"
        },
        {
          "const": "jni",
          "description": "Rust JNI shim crate emitter — paired with kotlin-android.\nEmits `Java_*` symbols that mirror the Kotlin Bridge `external fun` declarations.",
          "type": "string"
        }
      ]
    },
    "LintConfig": {
      "properties": {
        "before": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ],
          "description": "Command(s) to run before the main lint commands; aborts on failure."
        },
        "check": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ]
        },
        "format": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ]
        },
        "precondition": {
          "description": "Shell command that must exit 0 for lint to run; skip with warning on failure.",
          "type": [
            "string",
            "null"
          ]
        },
        "typecheck": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "type": "object"
    },
    "ManifestExtras": {
      "description": "Extra dependencies declared for a language-native manifest. `dependencies` and\n`dev_dependencies` mirror the runtime / dev-test distinction present in\nnpm, Composer, Bundler, pubspec, Mix, etc. Languages without that distinction\n(Go, Zig, Kotlin `testImplementation`) collapse both buckets into one at the\nemitter level.",
      "properties": {
        "dependencies": {
          "additionalProperties": {
            "$ref": "#/$defs/ExtraDepSpec"
          },
          "default": {},
          "description": "Runtime dependencies (e.g. `dependencies` in package.json, `requires` in\npyproject, `dependencies` in composer.json).",
          "type": "object"
        },
        "dev_dependencies": {
          "additionalProperties": {
            "$ref": "#/$defs/ExtraDepSpec"
          },
          "default": {},
          "description": "Dev / test dependencies (e.g. `devDependencies` in package.json,\n`require-dev` in composer.json, `group :test do` in Gemfile).",
          "type": "object"
        }
      },
      "type": "object"
    },
    "NapiTypeTagConfig": {
      "description": "An N-API `napi_type_tag` value, expressed as two 64-bit hex strings.",
      "properties": {
        "lower": {
          "description": "Lower 64 bits of the tag, hex (e.g. `\"0x8AF2E5212AD58ABF\"`).",
          "type": "string"
        },
        "upper": {
          "description": "Upper 64 bits of the tag, hex (e.g. `\"0xD5006CAD83ABBA16\"`).",
          "type": "string"
        }
      },
      "required": [
        "lower",
        "upper"
      ],
      "type": "object"
    },
    "NodeCapsuleTypeConfig": {
      "description": "Configuration for a single capsule type entry in `NodeConfig::capsule_types`.\n\nWhen set, the named Rust type is NOT emitted as a `#[napi]` opaque wrapper.\nInstead, functions returning this type produce a `JsObject` carrying the raw\npointer in a configurable `Napi::External<T>` property — the layout consumed\nby the `sample_language` npm package's `Parser.setLanguage()`.\n\nTOML form:\n```toml\n[crates.node.capsule_types.Language]\ntype = \"Language\"\nfrom_module = \"sample_language\"\nproperty_name = \"language\"\ntype_tag = { lower = \"0x8AF2E5212AD58ABF\", upper = \"0xD5006CAD83ABBA16\" }\n```",
      "properties": {
        "construct": {
          "default": "external_pointer",
          "description": "Codegen strategy. Currently only `\"external_pointer\"` is supported.\nDefaults to `\"external_pointer\"`.",
          "type": "string"
        },
        "from_module": {
          "description": "npm package to import the type from (e.g. `\"sample_language\"`).\nEmitted as the `from` clause in the generated `import type` line.",
          "type": "string"
        },
        "property_name": {
          "default": "__parser",
          "description": "JS property name to set on the returned object. `node-sample_language`\nreads `value[\"language\"]`; other consumers may use different names.\nDefaults to `\"__parser\"` for back-compat with existing configs.",
          "type": "string"
        },
        "type": {
          "description": "User-facing class name in the ecosystem library (e.g. `\"Language\"`).\nEmitted as the return-type annotation in the generated `index.d.ts`.",
          "type": "string"
        },
        "type_tag": {
          "anyOf": [
            {
              "$ref": "#/$defs/NapiTypeTagConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Optional N-API type tag to apply via `napi_type_tag_object`. Required\nwhen the consumer library (e.g. `node-sample_language`) calls\n`napi_check_object_type_tag` to validate the External before using it."
        }
      },
      "required": [
        "type",
        "from_module"
      ],
      "type": "object"
    },
    "NodeConfig": {
      "properties": {
        "capsule_types": {
          "additionalProperties": {
            "$ref": "#/$defs/NodeCapsuleTypeConfig"
          },
          "default": {},
          "description": "Map of Rust type name -> capsule config for raw-pointer passthrough.\nTypes listed here skip the default `#[napi]` opaque-wrapper emission;\nfunctions returning them produce a `JsObject` with a `__parser`\n`Napi::External<T>` property instead. See [`NodeCapsuleTypeConfig`].",
          "type": "object"
        },
        "crate_dir": {
          "default": null,
          "description": "Overrides the default `crates/{name}-node` formula for the crate directory.\nUseful when the Rust crate directory does not follow the alef convention\n(e.g., consumer strips a `-rs` suffix so actual crate dir is `crates/sample-markdown-node`\ninstead of `crates/sample-markdown-rs-node`). Used by setup, test, clean, and format tasks.",
          "type": [
            "string",
            "null"
          ]
        },
        "exclude_functions": {
          "default": [],
          "description": "Functions to exclude from Node binding generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "exclude_platforms": {
          "default": [],
          "description": "napi-rs platforms to drop from generated `package.json.napi.targets`,\n`optionalDependencies`, runtime dispatch table, and per-platform stub\ndirectories. Values are napi-rs platform strings (e.g.\n`\"linux-x64-musl\"`, `\"linux-arm64-musl\"`). Useful when downstream\npublish pipelines do not produce binaries for a platform yet the alef\ndefaults would otherwise emit dangling stub packages.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "exclude_types": {
          "default": [],
          "description": "Types to exclude from Node binding generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "extra_dependencies": {
          "additionalProperties": true,
          "default": {},
          "description": "Additional Cargo dependencies for this language's binding crate only.",
          "type": "object"
        },
        "extra_lint_paths": {
          "default": [],
          "description": "Extra paths to append to default lint commands (format, check, typecheck).",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "features": {
          "default": null,
          "description": "Per-language feature override. When set, these features are used instead of\n`[crate] features` for this language's binding crate.",
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "package_name": {
          "type": [
            "string",
            "null"
          ]
        },
        "rename_fields": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Per-field name remapping for this language. Key is `TypeName.field_name`, value is the\ndesired binding field name. Applied after automatic keyword escaping.",
          "type": "object"
        },
        "run_wrapper": {
          "default": null,
          "description": "Prefix wrapper for default tool invocations. When set, prepends this string to default\ncommands across all pipelines (lint, test, build, etc.).",
          "type": [
            "string",
            "null"
          ]
        },
        "scaffold_output": {
          "default": null,
          "description": "Override the scaffold output directory for this language's Cargo.toml and package files.",
          "type": [
            "string",
            "null"
          ]
        },
        "serde_rename_all": {
          "default": null,
          "description": "Override the serde rename_all strategy for JSON field names (e.g. \"camelCase\", \"snake_case\").\nWhen set, this takes priority over the IR type-level serde_rename_all.",
          "type": [
            "string",
            "null"
          ]
        },
        "tokio_util_features": {
          "default": null,
          "description": "Features for the auto-emitted `tokio-util` dependency that backs napi trait-bridge\ncancellation tokens. Defaults to `[\"rt\"]` because `tokio_util::sync::CancellationToken`\nis gated behind the `rt` feature in tokio-util 0.7+. Override when a consumer needs\nadditional tokio-util features (e.g. `[\"rt\", \"codec\"]`).",
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "type_prefix": {
          "default": null,
          "description": "Prefix for generated type names (e.g. \"Js\" produces `JsConversionOptions`).\nDefaults to `\"Js\"`.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "NodeDtoStyle": {
      "enum": [
        "interface",
        "zod"
      ],
      "type": "string"
    },
    "OutputConfig": {
      "properties": {
        "csharp": {
          "type": [
            "string",
            "null"
          ]
        },
        "dart": {
          "type": [
            "string",
            "null"
          ]
        },
        "elixir": {
          "type": [
            "string",
            "null"
          ]
        },
        "ffi": {
          "type": [
            "string",
            "null"
          ]
        },
        "gleam": {
          "type": [
            "string",
            "null"
          ]
        },
        "go": {
          "type": [
            "string",
            "null"
          ]
        },
        "java": {
          "type": [
            "string",
            "null"
          ]
        },
        "kotlin": {
          "type": [
            "string",
            "null"
          ]
        },
        "kotlin_android": {
          "type": [
            "string",
            "null"
          ]
        },
        "node": {
          "type": [
            "string",
            "null"
          ]
        },
        "php": {
          "type": [
            "string",
            "null"
          ]
        },
        "python": {
          "type": [
            "string",
            "null"
          ]
        },
        "r": {
          "type": [
            "string",
            "null"
          ]
        },
        "ruby": {
          "type": [
            "string",
            "null"
          ]
        },
        "swift": {
          "type": [
            "string",
            "null"
          ]
        },
        "wasm": {
          "type": [
            "string",
            "null"
          ]
        },
        "zig": {
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "OutputTemplate": {
      "description": "Per-language output path templates for multi-crate workspaces.\n\nEach entry is a path string that may contain `{crate}` and `{lang}` placeholders.\nResolved by [`OutputTemplate::resolve`] to produce a concrete path for one\n`(crate, language)` pair.\n\nDefaults (when a language entry is absent and no per-crate explicit override is set):\n- Single-crate workspaces resolve to `packages/{lang}/`.\n- Multi-crate workspaces resolve to `packages/{lang}/{crate}/`.\n\nPer-crate explicit paths in [`OutputConfig`] always win over a workspace template.",
      "properties": {
        "csharp": {
          "type": [
            "string",
            "null"
          ]
        },
        "dart": {
          "type": [
            "string",
            "null"
          ]
        },
        "elixir": {
          "type": [
            "string",
            "null"
          ]
        },
        "ffi": {
          "type": [
            "string",
            "null"
          ]
        },
        "gleam": {
          "type": [
            "string",
            "null"
          ]
        },
        "go": {
          "type": [
            "string",
            "null"
          ]
        },
        "java": {
          "type": [
            "string",
            "null"
          ]
        },
        "kotlin": {
          "type": [
            "string",
            "null"
          ]
        },
        "kotlin_android": {
          "type": [
            "string",
            "null"
          ]
        },
        "node": {
          "type": [
            "string",
            "null"
          ]
        },
        "php": {
          "type": [
            "string",
            "null"
          ]
        },
        "python": {
          "type": [
            "string",
            "null"
          ]
        },
        "r": {
          "type": [
            "string",
            "null"
          ]
        },
        "ruby": {
          "type": [
            "string",
            "null"
          ]
        },
        "swift": {
          "type": [
            "string",
            "null"
          ]
        },
        "wasm": {
          "type": [
            "string",
            "null"
          ]
        },
        "zig": {
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "PackageMetadataConfig": {
      "additionalProperties": false,
      "description": "Shared package metadata used by language package manifests.\n\nValues can be set at `[workspace.package_metadata]` and overridden per\n`[[crates]]` entry with `[crates.package_metadata]`.",
      "properties": {
        "authors": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "categories": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "description": {
          "default": null,
          "type": [
            "string",
            "null"
          ]
        },
        "documentation": {
          "default": null,
          "type": [
            "string",
            "null"
          ]
        },
        "funding": {
          "default": null,
          "type": [
            "string",
            "null"
          ]
        },
        "homepage": {
          "default": null,
          "type": [
            "string",
            "null"
          ]
        },
        "issues": {
          "default": null,
          "type": [
            "string",
            "null"
          ]
        },
        "keywords": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "license": {
          "default": null,
          "type": [
            "string",
            "null"
          ]
        },
        "repository": {
          "default": null,
          "type": [
            "string",
            "null"
          ]
        },
        "truncate_registry_lists": {
          "default": false,
          "description": "If true, registry-specific keyword/category limits are truncated\ndeterministically instead of failing validation.",
          "type": "boolean"
        }
      },
      "type": "object"
    },
    "PackageRef": {
      "description": "Per-language package reference configuration.",
      "properties": {
        "cli_formula": {
          "default": null,
          "description": "Homebrew CLI formula name (e.g., `\"sample-markdown\"`).\n\nUsed by the `homebrew` test_app generator.",
          "type": [
            "string",
            "null"
          ]
        },
        "cli_tests": {
          "default": [],
          "description": "CLI test steps for the Homebrew test_app generator.\n\nWhen empty (the default) a single default `--version` check is emitted\nthat asserts `$VERSION` appears in the output.  Provide explicit entries\nto replace the default entirely.\n\nUsed by the `homebrew` test_app generator.",
          "items": {
            "$ref": "#/$defs/HomebrewCliTest"
          },
          "type": "array"
        },
        "ffi_formula": {
          "default": null,
          "description": "Homebrew FFI shared-library formula name (e.g., `\"libsample-markdown\"`).\n\nWhen not set, FFI-related sections (Brewfile entry, compile/run block,\n`ffi_smoke.c`) are omitted from the generated test_app.\n\nUsed by the `homebrew` test_app generator.",
          "type": [
            "string",
            "null"
          ]
        },
        "hash": {
          "default": null,
          "description": "SHA-256 hash of the published tarball (Zig registry mode).\n\nWhen present without `platform_hashes`, emitted for the generic package tarball.\nMulti-platform Zig release assets must use `platform_hashes` because Zig hashes are\ncontent-specific.",
          "type": [
            "string",
            "null"
          ]
        },
        "module": {
          "default": null,
          "description": "Go module path.",
          "type": [
            "string",
            "null"
          ]
        },
        "name": {
          "default": null,
          "description": "Package/crate/gem/module name.",
          "type": [
            "string",
            "null"
          ]
        },
        "path": {
          "default": null,
          "description": "Relative path from e2e/{lang}/ to the package.",
          "type": [
            "string",
            "null"
          ]
        },
        "platform_hashes": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Platform-specific Zig package hashes keyed by platform suffix\n(`linux-x86_64`, `linux-aarch64`, `macos-arm64`, `macos-x86_64`, `windows-x86_64`).\n\nWhen present in registry mode, alef emits one lazy dependency per platform.",
          "type": "object"
        },
        "tap": {
          "default": null,
          "description": "Homebrew tap name (e.g., `\"sample_core-dev/tap\"`).\n\nUsed by the `homebrew` test_app generator.",
          "type": [
            "string",
            "null"
          ]
        },
        "version": {
          "default": null,
          "description": "Package version (e.g., for go.mod require directives).",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "PhpConfig": {
      "properties": {
        "cargo_crate_name": {
          "default": null,
          "description": "Cargo crate name for the PHP binding (e.g. `\"parser-core-core-php\"`).\nUsed to derive the shared library filename in the e2e test runner.\nWhen absent, the lib name is derived from `extension_name` by appending `_php`.",
          "type": [
            "string",
            "null"
          ]
        },
        "composer_package": {
          "default": null,
          "description": "Override composer package name (vendor/package-name) for composer.json generation.\nWhen absent, vendor/package is derived from the repository URL.\nFormat: \"vendor/package-name\" (e.g., \"example/sample-lib\").",
          "type": [
            "string",
            "null"
          ]
        },
        "exclude_functions": {
          "default": [],
          "description": "Functions to exclude from PHP binding generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "exclude_types": {
          "default": [],
          "description": "Types to exclude from PHP binding generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "extension_name": {
          "type": [
            "string",
            "null"
          ]
        },
        "extra_dependencies": {
          "additionalProperties": true,
          "default": {},
          "description": "Additional Cargo dependencies for this language's binding crate only.",
          "type": "object"
        },
        "extra_lint_paths": {
          "default": [],
          "description": "Extra paths to append to default lint commands (format, check, typecheck).",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "feature_gate": {
          "default": null,
          "description": "Feature gate for ext-php-rs (default: \"extension-module\").\nAll generated code is wrapped in `#[cfg(feature = \"...\")]`.",
          "type": [
            "string",
            "null"
          ]
        },
        "features": {
          "default": null,
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "namespace": {
          "default": null,
          "description": "Override the PHP namespace used for class registration and PSR-4 autoloading.\n\nWhen set, this value is used verbatim as the PHP namespace (e.g. `\"SampleMarkdown\"`).\nWhen absent, the namespace is derived from `extension_name` by splitting on `_` and\nconverting each segment to PascalCase (e.g. `sample_markdown` → `Html\\To\\Markdown`).",
          "type": [
            "string",
            "null"
          ]
        },
        "rename_fields": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Per-field name remapping for this language. Key is `TypeName.field_name`, value is the\ndesired binding field name. Applied after automatic keyword escaping.",
          "type": "object"
        },
        "run_wrapper": {
          "default": null,
          "description": "Prefix wrapper for default tool invocations. When set, prepends this string to default\ncommands across all pipelines (lint, test, build, etc.).",
          "type": [
            "string",
            "null"
          ]
        },
        "scaffold_output": {
          "default": null,
          "description": "Override the scaffold output directory for this language's Cargo.toml and package files.",
          "type": [
            "string",
            "null"
          ]
        },
        "serde_rename_all": {
          "default": null,
          "description": "Override the serde rename_all strategy for JSON field names (e.g. \"camelCase\", \"snake_case\").\nWhen set, this takes priority over the IR type-level serde_rename_all.",
          "type": [
            "string",
            "null"
          ]
        },
        "stubs": {
          "anyOf": [
            {
              "$ref": "#/$defs/StubsConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Output directory for generated PHP facade / stubs (e.g., `packages/php/src/`)."
        }
      },
      "type": "object"
    },
    "PhpDtoStyle": {
      "enum": [
        "readonly-class",
        "array"
      ],
      "type": "string"
    },
    "PrecommitConfig": {
      "properties": {
        "alef_hooks_repo": {
          "default": null,
          "description": "Repository URL for the alef hook block.",
          "type": [
            "string",
            "null"
          ]
        },
        "alef_hooks_rev": {
          "default": null,
          "description": "Revision for the alef hook block.",
          "type": [
            "string",
            "null"
          ]
        },
        "include_alef_hooks": {
          "default": null,
          "description": "Whether to include the alef hook block.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "include_shared_hooks": {
          "default": null,
          "description": "Whether to include the shared shell/Docker/docs hooks block.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "shared_hooks_repo": {
          "default": null,
          "description": "Repository URL for the shared hooks block.",
          "type": [
            "string",
            "null"
          ]
        },
        "shared_hooks_rev": {
          "default": null,
          "description": "Revision for the shared hooks block.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "PublishConfig": {
      "description": "Configuration for the `alef publish` command group.",
      "properties": {
        "core_crate": {
          "description": "Path to the core Rust crate directory to vendor.\nAuto-detected from `[crate].sources` if absent.",
          "type": [
            "string",
            "null"
          ]
        },
        "languages": {
          "additionalProperties": {
            "$ref": "#/$defs/PublishLanguageConfig"
          },
          "default": {},
          "description": "Per-language publish configuration overrides.",
          "type": "object"
        }
      },
      "type": "object"
    },
    "PublishLanguageConfig": {
      "description": "Per-language publish configuration.",
      "properties": {
        "after": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ],
          "description": "Command(s) to run after the main publish commands; aborts on failure."
        },
        "archive_format": {
          "description": "Archive format override (`\"tar.gz\"` or `\"zip\"`).",
          "type": [
            "string",
            "null"
          ]
        },
        "before": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ],
          "description": "Command(s) to run before the main publish commands; aborts on failure."
        },
        "build_command": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ],
          "description": "Override the default build command for cross-compilation."
        },
        "cibuildwheel_environment": {
          "additionalProperties": {
            "type": "string"
          },
          "description": "Forward-looking: environment variables passed through to cibuildwheel\nwhen orchestrating Python cross-compilation builds.",
          "type": [
            "object",
            "null"
          ]
        },
        "cmake_config": {
          "description": "Generate a CMake find module (C FFI only).",
          "type": [
            "boolean",
            "null"
          ]
        },
        "csharp_rid": {
          "description": "NuGet RID override for C# packaging (e.g. `\"linux-x64\"`).\nDerived from the target triple when absent.",
          "type": [
            "string",
            "null"
          ]
        },
        "jni_classifier": {
          "description": "JNI classifier override for Java packaging (e.g. `\"linux-x86_64\"`).\nDerived from the target triple when absent.",
          "type": [
            "string",
            "null"
          ]
        },
        "nif_versions": {
          "description": "Elixir NIF versions to build for (e.g. `[\"2.16\", \"2.17\"]`).",
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "npm_subpackage_platforms": {
          "description": "npm sub-package platform identifiers for Node.js NAPI builds.\nEach entry is a napi-rs platform string like `\"linux-x64-gnu\"`.\nDefaults to a standard set when absent.",
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "package_command": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ],
          "description": "Override the default package command."
        },
        "pkg_config": {
          "description": "Generate a pkg-config `.pc` file (C FFI only).",
          "type": [
            "boolean",
            "null"
          ]
        },
        "precondition": {
          "description": "Shell command that must exit 0 for publish steps to run; skip with warning on failure.",
          "type": [
            "string",
            "null"
          ]
        },
        "sdist": {
          "description": "Build and include a Python sdist (default: `true`).",
          "type": [
            "boolean",
            "null"
          ]
        },
        "vendor_mode": {
          "anyOf": [
            {
              "$ref": "#/$defs/VendorMode"
            },
            {
              "type": "null"
            }
          ],
          "description": "Vendoring strategy for this language."
        },
        "wheel": {
          "description": "Build and include a Python wheel for this target (default: `true`).",
          "type": [
            "boolean",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "PythonConfig": {
      "properties": {
        "async_runtime": {
          "type": [
            "string",
            "null"
          ]
        },
        "capsule_types": {
          "additionalProperties": {
            "$ref": "#/$defs/CapsuleTypeConfig"
          },
          "default": {},
          "description": "Map of type name -> capsule config for PyCapsule pass-through.\nTypes listed here are emitted as PyCapsule_New / PyCapsule_GetPointer instead of\nopaque `#[pyclass]` wrappers. Use `CapsuleTypeConfig::Capsule` for raw capsule\nround-trips and `CapsuleTypeConfig::ConstructFrom` for Python-side construction.",
          "type": "object"
        },
        "exclude_functions": {
          "default": [],
          "description": "Functions to exclude from Python binding generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "exclude_types": {
          "default": [],
          "description": "Types to exclude from Python binding generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "extra_dependencies": {
          "additionalProperties": true,
          "default": {},
          "description": "Additional Cargo dependencies for this language's binding crate only.",
          "type": "object"
        },
        "extra_init_imports": {
          "additionalProperties": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "default": {},
          "description": "Additional `from <module> import <symbol>` lines to emit in the generated `__init__.py`.\nKey is the relative or absolute Python module path (e.g. `\"._supported_languages\"`),\nvalue is the list of symbols to import. The symbols are also added to `__all__`.\n\nUse this to re-export hand-written sibling modules (e.g. generated by a project's own\nbuild script) without alef's cleanup culling them. The hand-written file must NOT contain\nthe substrings `\"DO NOT EDIT\"`, `\"auto-generated by alef\"`, or `\"AUTO-GENERATED by alef\"`\nin its first 5 lines, or alef's cleanup pipeline will treat it as a stale alef artifact.",
          "type": "object"
        },
        "extra_lint_paths": {
          "default": [],
          "description": "Extra paths to append to default lint commands (format, check, typecheck).\nSpace-separated paths are appended to the command.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "features": {
          "default": null,
          "description": "Per-language feature override. When set, these features are used instead of\n`[crate] features` for this language's binding crate.",
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "module_name": {
          "type": [
            "string",
            "null"
          ]
        },
        "pip_dependencies": {
          "default": [],
          "description": "Runtime Python (PyPI) dependencies emitted into `[project] dependencies`\nof the scaffold-generated `pyproject.toml`. Entries are PEP 508 strings\nsuch as `\"sample_language>=0.23\"` and pass through verbatim. Empty by default.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "pip_name": {
          "default": null,
          "description": "PyPI package name (e.g. `\"sample-markdown\"`). Used as the `[project] name` in\n`pyproject.toml` and to derive the `python-packages` list for maturin.\nDefaults to the crate name.",
          "type": [
            "string",
            "null"
          ]
        },
        "reexported_types": {
          "default": [],
          "description": "Type names to skip `_rust.` qualification in function return-type annotations.\nList type names that are re-exported in the public `__init__.py` to avoid\nannotating them with `_rust.TypeName` (which causes type-checker confusion when\nthe type is also imported as a bare name in the public API).\nExample: `[\"ExtractionResult\", \"ExtractionDiff\"]` makes function returns bare\n`ExtractionResult` instead of `_rust.ExtractionResult`.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "release_gil": {
          "default": false,
          "description": "When true, wrap blocking function bodies in py.allow_threads() to release the GIL.",
          "type": "boolean"
        },
        "rename_fields": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Per-field name remapping for this language. Key is `TypeName.field_name` (e.g.\n`\"LayoutDetection.class\"`), value is the desired binding field name. Applied after\nautomatic keyword escaping, so an explicit entry takes priority.",
          "type": "object"
        },
        "run_wrapper": {
          "default": null,
          "description": "Prefix wrapper for default tool invocations. When set, prepends this string to default\ncommands across all pipelines (lint, test, build, etc.).\nE.g., `run_wrapper = \"uv run --no-sync\"` turns `ruff format packages/python` into\n`uv run --no-sync ruff format packages/python`.",
          "type": [
            "string",
            "null"
          ]
        },
        "scaffold_output": {
          "default": null,
          "description": "Override the scaffold output directory for this language's Cargo.toml and package files.",
          "type": [
            "string",
            "null"
          ]
        },
        "serde_rename_all": {
          "default": null,
          "description": "Override the serde rename_all strategy for JSON field names (e.g. \"camelCase\", \"snake_case\").\nWhen set, this takes priority over the IR type-level serde_rename_all.",
          "type": [
            "string",
            "null"
          ]
        },
        "stubs": {
          "anyOf": [
            {
              "$ref": "#/$defs/StubsConfig"
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "type": "object"
    },
    "PythonDtoStyle": {
      "enum": [
        "dataclass",
        "typed-dict",
        "pydantic",
        "msgspec"
      ],
      "type": "string"
    },
    "RConfig": {
      "properties": {
        "exclude_functions": {
          "default": [],
          "description": "Functions to exclude from R binding generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "exclude_types": {
          "default": [],
          "description": "Types to exclude from R binding generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "extra_lint_paths": {
          "default": [],
          "description": "Extra paths to append to default lint commands (format, check, typecheck).",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "features": {
          "default": null,
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "package_name": {
          "type": [
            "string",
            "null"
          ]
        },
        "rename_fields": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Per-field name remapping for this language. Key is `TypeName.field_name`, value is the\ndesired binding field name. Applied after automatic keyword escaping.",
          "type": "object"
        },
        "run_wrapper": {
          "default": null,
          "description": "Prefix wrapper for default tool invocations. When set, prepends this string to default\ncommands across all pipelines (lint, test, build, etc.).",
          "type": [
            "string",
            "null"
          ]
        },
        "serde_rename_all": {
          "default": null,
          "description": "Override the serde rename_all strategy for JSON field names (e.g. \"camelCase\", \"snake_case\").\nWhen set, this takes priority over the IR type-level serde_rename_all.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "RDtoStyle": {
      "enum": [
        "list",
        "r6"
      ],
      "type": "string"
    },
    "RawCrateConfig": {
      "additionalProperties": false,
      "description": "One `[[crates]]` entry — an independently published Rust facade plus its\nper-crate language settings, pipelines, and packaging metadata.\n\nEvery field except `name` is optional. Fields left unset inherit from\nthe workspace defaults during resolution; required fields with no\nworkspace default fall back to Alef's built-in defaults or trigger a\nvalidation error.",
      "properties": {
        "adapters": {
          "default": [],
          "items": {
            "$ref": "#/$defs/AdapterConfig"
          },
          "type": "array"
        },
        "auto_path_mappings": {
          "default": null,
          "description": "Automatically derive path mappings from source file locations.\nDefault: `true`.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "build_commands": {
          "additionalProperties": {
            "$ref": "#/$defs/BuildCommandConfig"
          },
          "default": {},
          "type": "object"
        },
        "clean": {
          "additionalProperties": {
            "$ref": "#/$defs/CleanConfig"
          },
          "default": {},
          "type": "object"
        },
        "core_import": {
          "default": null,
          "description": "Rust import path for the core crate referenced from generated bindings.\nDefaults to the crate name with hyphens replaced by underscores.",
          "type": [
            "string",
            "null"
          ]
        },
        "csharp": {
          "anyOf": [
            {
              "$ref": "#/$defs/CSharpConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "custom_files": {
          "additionalProperties": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "default": {},
          "type": "object"
        },
        "custom_modules": {
          "$ref": "#/$defs/CustomModulesConfig",
          "default": {
            "csharp": [],
            "elixir": [],
            "ffi": [],
            "go": [],
            "java": [],
            "node": [],
            "php": [],
            "python": [],
            "r": [],
            "ruby": [],
            "wasm": []
          }
        },
        "custom_registrations": {
          "$ref": "#/$defs/CustomRegistrationsConfig",
          "default": {
            "elixir": null,
            "node": null,
            "php": null,
            "python": null,
            "ruby": null,
            "wasm": null
          }
        },
        "dart": {
          "anyOf": [
            {
              "$ref": "#/$defs/DartConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "dto": {
          "anyOf": [
            {
              "$ref": "#/$defs/DtoConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Override the workspace default DTO styles. When `Some`, replaces the\nworkspace value wholesale (no field-level merge — a partial DTO override\nwould silently drop unspecified language entries)."
        },
        "e2e": {
          "anyOf": [
            {
              "$ref": "#/$defs/E2eConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "elixir": {
          "anyOf": [
            {
              "$ref": "#/$defs/ElixirConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "error_constructor": {
          "default": null,
          "description": "Pattern for constructing error values from a String in trait bridges.\n`{msg}` is replaced with the format!(...) expression.",
          "type": [
            "string",
            "null"
          ]
        },
        "error_type": {
          "default": null,
          "description": "Crate error type name (e.g. `\"SampleCrateError\"`). Used by trait-bridge\ngeneration. Defaults to `\"Error\"`.",
          "type": [
            "string",
            "null"
          ]
        },
        "exclude": {
          "$ref": "#/$defs/ExcludeConfig",
          "default": {
            "functions": [],
            "methods": [],
            "types": []
          }
        },
        "extra_dependencies": {
          "additionalProperties": true,
          "default": {},
          "description": "Additional Cargo dependencies merged into every binding crate Cargo.toml\nfor this crate (per-language extra_dependencies still override these).",
          "type": "object"
        },
        "features": {
          "default": [],
          "description": "Cargo features enabled in binding crates. Fields gated by\n`#[cfg(feature = \"...\")]` matching these features are treated as\nalways present (cfg stripped from the IR).",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "ffi": {
          "anyOf": [
            {
              "$ref": "#/$defs/FfiConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "format": {
          "anyOf": [
            {
              "$ref": "#/$defs/FormatConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Override the workspace default `format` flags. When `Some`, replaces the\nworkspace value wholesale."
        },
        "format_overrides": {
          "additionalProperties": {
            "$ref": "#/$defs/FormatConfig"
          },
          "default": {},
          "description": "Per-language per-crate formatting overrides keyed by language code.\nMerged with workspace `format_overrides`: per-crate keys win wholesale,\nmissing keys fall through to the workspace map.",
          "type": "object"
        },
        "generate": {
          "anyOf": [
            {
              "$ref": "#/$defs/GenerateConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Override the workspace default `generate` flags. When `Some`, replaces the\nworkspace value wholesale. When `None`, the crate inherits `workspace.generate`."
        },
        "generate_overrides": {
          "additionalProperties": {
            "$ref": "#/$defs/GenerateConfig"
          },
          "default": {},
          "description": "Per-language per-crate generation flag overrides keyed by language code.\nMerged with workspace `generate_overrides`: per-crate keys win wholesale,\nmissing keys fall through to the workspace map.",
          "type": "object"
        },
        "gleam": {
          "anyOf": [
            {
              "$ref": "#/$defs/GleamConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "go": {
          "anyOf": [
            {
              "$ref": "#/$defs/GoConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "handler_contracts": {
          "default": [],
          "items": {
            "$ref": "#/$defs/HandlerContractConfig"
          },
          "type": "array"
        },
        "include": {
          "$ref": "#/$defs/IncludeConfig",
          "default": {
            "functions": [],
            "types": []
          }
        },
        "java": {
          "anyOf": [
            {
              "$ref": "#/$defs/JavaConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "jni": {
          "anyOf": [
            {
              "$ref": "#/$defs/JniConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "kotlin": {
          "anyOf": [
            {
              "$ref": "#/$defs/KotlinConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "kotlin_android": {
          "anyOf": [
            {
              "$ref": "#/$defs/KotlinAndroidConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "languages": {
          "default": null,
          "description": "Override of the workspace `languages` list for this crate.\nWhen `None`, this crate inherits the workspace default.",
          "items": {
            "$ref": "#/$defs/Language"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "lint": {
          "additionalProperties": {
            "$ref": "#/$defs/LintConfig"
          },
          "default": {},
          "type": "object"
        },
        "name": {
          "description": "Crate name (e.g. `\"sample_project\"`). Must be unique within the workspace.",
          "type": "string"
        },
        "node": {
          "anyOf": [
            {
              "$ref": "#/$defs/NodeConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "output": {
          "$ref": "#/$defs/OutputConfig",
          "default": {
            "csharp": null,
            "dart": null,
            "elixir": null,
            "ffi": null,
            "gleam": null,
            "go": null,
            "java": null,
            "kotlin": null,
            "kotlin_android": null,
            "node": null,
            "php": null,
            "python": null,
            "r": null,
            "ruby": null,
            "swift": null,
            "wasm": null,
            "zig": null
          },
          "description": "Per-crate explicit output paths. Wins over the workspace\n`output_template` for any language with an entry here."
        },
        "package_metadata": {
          "anyOf": [
            {
              "$ref": "#/$defs/PackageMetadataConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "path_mappings": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Maps extracted rust_path prefixes to actual import paths in binding crates.",
          "type": "object"
        },
        "php": {
          "anyOf": [
            {
              "$ref": "#/$defs/PhpConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "publish": {
          "anyOf": [
            {
              "$ref": "#/$defs/PublishConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "python": {
          "anyOf": [
            {
              "$ref": "#/$defs/PythonConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "r": {
          "anyOf": [
            {
              "$ref": "#/$defs/RConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "readme": {
          "anyOf": [
            {
              "$ref": "#/$defs/ReadmeConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "ruby": {
          "anyOf": [
            {
              "$ref": "#/$defs/RubyConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "scaffold": {
          "anyOf": [
            {
              "$ref": "#/$defs/ScaffoldConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "services": {
          "default": [],
          "items": {
            "$ref": "#/$defs/ServiceConfig"
          },
          "type": "array"
        },
        "setup": {
          "additionalProperties": {
            "$ref": "#/$defs/SetupConfig"
          },
          "default": {},
          "type": "object"
        },
        "skip_core_import": {
          "default": false,
          "description": "When true, skip adding `use {core_import};` to generated bindings.",
          "type": "boolean"
        },
        "source_crates": {
          "default": [],
          "description": "Multi-crate source groups for workspaces with types spread across\nsibling crates. When non-empty, the top-level `sources` field is ignored.",
          "items": {
            "$ref": "#/$defs/SourceCrate"
          },
          "type": "array"
        },
        "sources": {
          "default": [],
          "description": "Rust source files this crate's bindings extract from.\nMay be empty when [`source_crates`](Self::source_crates) is non-empty.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "suppress_validation_codes": {
          "default": [],
          "description": "Validation diagnostic codes that are downgraded from errors to warnings\nfor this crate, allowing generation to proceed despite pre-existing surface\nissues. Each entry is the string form of a [`crate::core::validation::ValidationCode`] (e.g.\n`\"lossy_sanitized_surface\"`, `\"unknown_named_type\"`).\n\nUse this to opt out of specific validation gates while you work toward full\ncompliance; remove entries once the underlying surface issues are fixed.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "swift": {
          "anyOf": [
            {
              "$ref": "#/$defs/SwiftConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "test": {
          "additionalProperties": {
            "$ref": "#/$defs/TestConfig"
          },
          "default": {},
          "type": "object"
        },
        "trait_bridges": {
          "default": [],
          "items": {
            "$ref": "#/$defs/TraitBridgeConfig"
          },
          "type": "array"
        },
        "update": {
          "additionalProperties": {
            "$ref": "#/$defs/UpdateConfig"
          },
          "default": {},
          "type": "object"
        },
        "version_from": {
          "default": null,
          "description": "File whose `[package] version` is the source of truth for this crate.\nDefaults to `\"Cargo.toml\"` (resolved relative to the alef.toml).",
          "type": [
            "string",
            "null"
          ]
        },
        "wasm": {
          "anyOf": [
            {
              "$ref": "#/$defs/WasmConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "workspace_root": {
          "default": null,
          "description": "Optional workspace root path for resolving `pub use` re-exports from\nsibling crates.",
          "type": [
            "string",
            "null"
          ]
        },
        "zig": {
          "anyOf": [
            {
              "$ref": "#/$defs/ZigConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        }
      },
      "required": [
        "name"
      ],
      "type": "object"
    },
    "ReadmeConfig": {
      "properties": {
        "banner_url": {
          "description": "Banner image URL used in README templates.",
          "type": [
            "string",
            "null"
          ]
        },
        "config": {
          "description": "Deprecated: path to an external YAML config file. Prefer inline fields below.",
          "type": [
            "string",
            "null"
          ]
        },
        "discord_url": {
          "description": "Discord invite URL used in README templates.",
          "type": [
            "string",
            "null"
          ]
        },
        "languages": {
          "additionalProperties": true,
          "default": {},
          "description": "Per-language README configuration, keyed by language code\n(e.g. \"python\", \"typescript\", \"ruby\"). Values are flexible JSON objects\nthat map directly to minijinja template context variables.",
          "type": "object"
        },
        "output_pattern": {
          "type": [
            "string",
            "null"
          ]
        },
        "snippets_dir": {
          "type": [
            "string",
            "null"
          ]
        },
        "template_dir": {
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "RegistrationSpec": {
      "description": "Per-registration configuration entry inside a `[[crates.services]]` table.\n\nExample in `alef.toml`:\n\n```toml\n[[crates.services.registrations]]\nmethod = \"add_route\"\ncallback_param = \"handler\"\ncallback_bound = \"IntoHandler\"\ncallback_contract = \"Handler\"\n\n[[crates.services.registrations.variants]]\nname = \"get\"\nfixed = { method = \"GET\" }\n```",
      "properties": {
        "callback_bound": {
          "description": "The generic type bound that the callback parameter uses\n(e.g. `\"IntoHandler\"`). Used to recognise which generic parameter to\nskip during the usual generic-method skip so the method is extracted.",
          "type": "string"
        },
        "callback_contract": {
          "description": "Name of the [`HandlerContractConfig`] (and trait) this callback maps to\n(e.g. `\"Handler\"`).",
          "type": "string"
        },
        "callback_param": {
          "description": "Name of the parameter that carries the callback (e.g. `\"handler\"`).",
          "type": "string"
        },
        "method": {
          "description": "Name of the method on the owner type (e.g. `\"add_route\"`).",
          "type": "string"
        },
        "variants": {
          "default": [],
          "description": "Named shortcuts over this registration with pinned parameter values.\nEach variant emits as an additional method on the service owner whose\nsignature drops the pinned params and whose body forwards to this base\nregistration with the pinned values substituted in.",
          "items": {
            "$ref": "#/$defs/RegistrationVariantSpec"
          },
          "type": "array"
        }
      },
      "required": [
        "method",
        "callback_param",
        "callback_bound",
        "callback_contract"
      ],
      "type": "object"
    },
    "RegistrationVariantSpec": {
      "description": "A named shortcut over a base [`RegistrationSpec`] with one or more pinned\nparameter values.\n\nThe variant's emitted method takes the **non-pinned** subset of the base's\nmetadata params and forwards them, along with the handler, to the base\nregistration with the pinned values substituted in. For library-supplied\nenum overrides, the pinned value is the variant *name* (e.g. `\"GET\"`); the\nextractor resolves it against the param type's [`crate::core::ir::EnumDef`] variants. For\nnon-enum types, the pinned value is a verbatim expression in the host\nlanguage's Rust bridge.\n\n```toml\n[[crates.services.registrations.variants]]\nname = \"get\"\nfixed = { method = \"GET\" }\nstyle = \"verb_decorator\"\n```",
      "properties": {
        "doc": {
          "default": null,
          "description": "Optional documentation for the variant. When absent, backends emit a\ngeneric docstring referencing the base registration.",
          "type": [
            "string",
            "null"
          ]
        },
        "fixed": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Map of base-registration metadata-param name → pinned value expression.\nFor enum-typed params, the value is the enum variant name. For other\ntypes, the value is a verbatim expression substituted in the wrapper\nconstructor call.",
          "type": "object"
        },
        "name": {
          "description": "Shortcut name (e.g. `\"get\"`). Used as the variant method's name on the\nowner, transformed to each language's idiomatic casing by the backend\ntemplates.",
          "type": "string"
        },
        "style": {
          "default": null,
          "description": "How backends should expose this variant's host-language surface.\n\nValid values (case-insensitive): `\"builder\"`, `\"verb_decorator\"`, `\"hybrid\"`.\nWhen absent, defaults to `\"hybrid\"` (both forms emitted), preserving\nbackward compatibility for consumers that have not yet migrated.\n\n- `\"builder\"` — emit only the decorator-factory form (`app.get(path)` returns a callable).\n- `\"verb_decorator\"` — emit only the direct method form (`app.get(path, handler)`).\n- `\"hybrid\"` — emit both forms (default).",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "required": [
        "name"
      ],
      "type": "object"
    },
    "RegistryConfig": {
      "description": "Configuration for registry-mode e2e generation (`alef e2e generate --registry`).",
      "properties": {
        "categories": {
          "default": [],
          "description": "When non-empty, only fixture categories in this list are included in\nregistry-mode generation (useful for shipping a curated subset).",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "github_repo": {
          "default": null,
          "description": "GitHub repository URL for downloading prebuilt artifacts (e.g., FFI\nshared libraries) from GitHub Releases.\n\nFalls back to `[scaffold] repository` when not set. Registry generators\nthat need a concrete release host should fail when no repository is\nconfigured instead of inventing publishable metadata.",
          "type": [
            "string",
            "null"
          ]
        },
        "output": {
          "default": "test_apps",
          "description": "Output directory for registry-mode test apps (default: \"test_apps\").",
          "type": "string"
        },
        "packages": {
          "additionalProperties": {
            "$ref": "#/$defs/PackageRef"
          },
          "default": {},
          "description": "Per-language package overrides used only in registry mode.\nMerged on top of the base `[e2e.packages]` entries.",
          "type": "object"
        },
        "run": {
          "additionalProperties": {
            "$ref": "#/$defs/TestAppRunConfig"
          },
          "default": {},
          "description": "Per-language commands that install the published package into the\nregistry-mode test app and exercise it, executed by `alef test-apps run`.\nLanguages omitted here fall back to `test_apps_run_defaults`.",
          "type": "object"
        }
      },
      "type": "object"
    },
    "RubyConfig": {
      "properties": {
        "exclude_functions": {
          "default": [],
          "description": "Functions to exclude from Ruby binding generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "exclude_types": {
          "default": [],
          "description": "Types to exclude from Ruby binding generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "extra_dependencies": {
          "additionalProperties": true,
          "default": {},
          "description": "Additional Cargo dependencies for this language's binding crate only.",
          "type": "object"
        },
        "extra_lint_paths": {
          "default": [],
          "description": "Extra paths to append to default lint commands (format, check, typecheck).",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "features": {
          "default": null,
          "description": "Per-language feature override. When set, these features are used instead of\n`[crate] features` for this language's binding crate.",
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "gem_name": {
          "type": [
            "string",
            "null"
          ]
        },
        "rename_fields": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Per-field name remapping for this language. Key is `TypeName.field_name`, value is the\ndesired binding field name. Applied after automatic keyword escaping.",
          "type": "object"
        },
        "run_wrapper": {
          "default": null,
          "description": "Prefix wrapper for default tool invocations. When set, prepends this string to default\ncommands across all pipelines (lint, test, build, etc.).",
          "type": [
            "string",
            "null"
          ]
        },
        "scaffold_output": {
          "default": null,
          "description": "Override the scaffold output directory for this language's Cargo.toml and package files.",
          "type": [
            "string",
            "null"
          ]
        },
        "serde_rename_all": {
          "default": null,
          "description": "Override the serde rename_all strategy for JSON field names (e.g. \"camelCase\", \"snake_case\").\nWhen set, this takes priority over the IR type-level serde_rename_all.",
          "type": [
            "string",
            "null"
          ]
        },
        "stubs": {
          "anyOf": [
            {
              "$ref": "#/$defs/StubsConfig"
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "type": "object"
    },
    "RubyDtoStyle": {
      "enum": [
        "struct",
        "dry-struct",
        "data"
      ],
      "type": "string"
    },
    "ScaffoldCargo": {
      "description": "Opt-in management of workspace-level `.cargo/config.toml`.\n\nAll fields default to canonical values that produce the same `.cargo/config.toml`\nacross polyglot repos. Override individual targets via `targets`, or inject\nrepo-specific `[env]` entries via `env`.",
      "properties": {
        "build_jobs": {
          "default": 4,
          "description": "Limit concurrent rustc jobs to prevent OOM during large builds.\nDefaults to 4 (safe for 16 GB dev machines). Set to 0 to disable.",
          "format": "uint32",
          "minimum": 0,
          "type": "integer"
        },
        "env": {
          "additionalProperties": {
            "$ref": "#/$defs/ScaffoldCargoEnvValue"
          },
          "default": {},
          "description": "Free-form `[env]` entries copied verbatim into the generated file.\nValues can be a plain string or `{ value, relative }`. Empty by default.",
          "type": "object"
        },
        "targets": {
          "$ref": "#/$defs/ScaffoldCargoTargets",
          "default": {
            "aarch64_unknown_linux_gnu": true,
            "i686_pc_windows_msvc": true,
            "macos_dynamic_lookup": true,
            "wasm32_unknown_unknown": true,
            "x86_64_pc_windows_msvc": true,
            "x86_64_unknown_linux_musl": true
          },
          "description": "Per-target cross-compile / rustflags overrides. Defaults emit the canonical\n6-target template (macOS dynamic_lookup, Windows MSVC rust-lld x64+i686,\naarch64-linux-gnu cross-gcc, x86_64-linux-musl, wasm32 bulk-memory)."
        }
      },
      "type": "object"
    },
    "ScaffoldCargoEnvValue": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "properties": {
            "relative": {
              "default": false,
              "type": "boolean"
            },
            "value": {
              "type": "string"
            }
          },
          "required": [
            "value"
          ],
          "type": "object"
        }
      ],
      "description": "Value for a `[scaffold.cargo.env]` entry. Either a bare string (renders as\n`KEY = \"value\"`) or a structured form with `value` + optional `relative`."
    },
    "ScaffoldCargoTargets": {
      "description": "Per-target opt-out flags. All default to `true`.",
      "properties": {
        "aarch64_unknown_linux_gnu": {
          "default": true,
          "type": "boolean"
        },
        "i686_pc_windows_msvc": {
          "default": true,
          "type": "boolean"
        },
        "macos_dynamic_lookup": {
          "default": true,
          "type": "boolean"
        },
        "wasm32_unknown_unknown": {
          "default": true,
          "type": "boolean"
        },
        "x86_64_pc_windows_msvc": {
          "default": true,
          "type": "boolean"
        },
        "x86_64_unknown_linux_musl": {
          "default": true,
          "type": "boolean"
        }
      },
      "type": "object"
    },
    "ScaffoldConfig": {
      "properties": {
        "authors": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "cargo": {
          "anyOf": [
            {
              "$ref": "#/$defs/ScaffoldCargo"
            },
            {
              "type": "null"
            }
          ],
          "description": "Opt-in workspace `.cargo/config.toml` management. When present, alef writes\nthe full file with hash-based drift detection. Absent = legacy behavior\n(wasm32 block only, create-if-missing, unmanaged)."
        },
        "description": {
          "type": [
            "string",
            "null"
          ]
        },
        "generated_header": {
          "anyOf": [
            {
              "$ref": "#/$defs/GeneratedHeaderConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Generated-file header text overrides."
        },
        "homepage": {
          "type": [
            "string",
            "null"
          ]
        },
        "keywords": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "license": {
          "type": [
            "string",
            "null"
          ]
        },
        "precommit": {
          "anyOf": [
            {
              "$ref": "#/$defs/PrecommitConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Pre-commit scaffold overrides."
        },
        "repository": {
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "SelectWhen": {
      "description": "Condition for auto-selecting a named call config when the fixture matches.\n\nWhen a fixture does not specify `\"call\"`, the codegen normally uses the default\n`[e2e.call]`.  A `SelectWhen` condition on a named call allows automatic routing\nbased on the fixture's id, category, tags, or input shape.  All set fields must\nmatch (logical AND); a condition with no fields set never matches.\n\n```toml\n[e2e.calls.batch_scrape]\nselect_when = { input_has = \"batch_urls\" }\n\n[e2e.calls.crawl]\nselect_when = { category = \"crawl\" }\n\n[e2e.calls.batch_crawl_stream]\nselect_when = { category = \"stream\", id_prefix = \"batch_crawl_stream\" }\n```",
      "properties": {
        "category": {
          "default": null,
          "description": "Match when the fixture's resolved category equals this string.",
          "type": [
            "string",
            "null"
          ]
        },
        "id_glob": {
          "default": null,
          "description": "Match when the fixture's id matches this simple glob.\n\nOnly `*` (matches any run of characters) is supported. Use `id_prefix`\nfor plain prefix matches.",
          "type": [
            "string",
            "null"
          ]
        },
        "id_prefix": {
          "default": null,
          "description": "Match when the fixture's id starts with this prefix.",
          "type": [
            "string",
            "null"
          ]
        },
        "input_has": {
          "default": null,
          "description": "Match when the fixture's input object contains this key with a non-null value.",
          "type": [
            "string",
            "null"
          ]
        },
        "tag": {
          "default": null,
          "description": "Match when the fixture's tags include this tag.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "ServiceConfig": {
      "description": "Full configuration for one service definition in `[[crates.services]]`.\n\n```toml\n[[crates.services]]\nowner_type = \"App\"\nconstructor = \"new\"\nconfigurators = [\"set_address\", \"set_tls\"]\nskip_languages = [\"wasm\"]\n\n[[crates.services.registrations]]\nmethod = \"add_route\"\ncallback_param = \"handler\"\ncallback_bound = \"IntoHandler\"\ncallback_contract = \"Handler\"\n\n[[crates.services.entrypoints]]\nmethod = \"run\"\nkind = \"run\"\n```",
      "properties": {
        "configurators": {
          "default": [],
          "description": "Names of chaining configurator methods (no callbacks).",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "constructor": {
          "default": null,
          "description": "Name of the constructor method (defaults to `\"new\"` when absent).",
          "type": [
            "string",
            "null"
          ]
        },
        "entrypoints": {
          "default": [],
          "description": "Entrypoints — run or finalize methods.",
          "items": {
            "$ref": "#/$defs/EntrypointSpec"
          },
          "type": "array"
        },
        "host_app_inner_accessor": {
          "default": null,
          "description": "Verbatim Rust expression that accesses the inner host-app value from the\ngenerated wrapper type's `self` receiver in verb-method emission.\n\nWhen the host-app wrapper type (e.g. the napi or wasm binding's `App` struct)\nwraps the real service owner behind a field (e.g. `Arc<Mutex<Owner>>`), set\nthis to the expression that unlocks or dereferences it so the generated\nverb methods can call `owner.{base_method}(...)` on the real type.\n\nExample:\n```toml\nhost_app_inner_accessor = \"self.inner.lock().expect(\\\"app mutex poisoned\\\")\"\n```\n\nWhen absent (the default), verb methods emit `self.{base_method}(...)` directly,\nwhich is correct when the generated wrapper IS the owner type.",
          "type": [
            "string",
            "null"
          ]
        },
        "owner_type": {
          "description": "Name of the owner/builder type in the extracted surface (e.g. `\"App\"`).",
          "type": "string"
        },
        "registrations": {
          "default": [],
          "description": "Registration points — each binds a callback to a slot.",
          "items": {
            "$ref": "#/$defs/RegistrationSpec"
          },
          "type": "array"
        },
        "skip_languages": {
          "default": [],
          "description": "Language backends that should NOT generate a service API for this entry.\nValues must match canonical language names (`\"python\"`, `\"node\"`, etc.).",
          "items": {
            "type": "string"
          },
          "type": "array"
        }
      },
      "required": [
        "owner_type"
      ],
      "type": "object"
    },
    "SetupConfig": {
      "properties": {
        "before": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ],
          "description": "Command(s) to run before the main setup commands; aborts on failure."
        },
        "install": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ],
          "description": "Command(s) to install dependencies for this language."
        },
        "precondition": {
          "description": "Shell command that must exit 0 for setup to run; skip with warning on failure.",
          "type": [
            "string",
            "null"
          ]
        },
        "timeout_seconds": {
          "default": 1800,
          "description": "Timeout in seconds for the complete setup (precondition + before + install).",
          "format": "uint64",
          "minimum": 0,
          "type": "integer"
        },
        "workdir": {
          "default": null,
          "description": "Optional working directory (relative to repo root) for setup commands.\n\nWhen set, install commands run from `base_dir.join(workdir)` instead of\n`base_dir`. Required for languages whose manifest does not live at the\nworkspace root (Swift's `Package.swift`, Kotlin-Android's `gradlew`,\nDart's `pubspec.yaml`, Zig's `build.zig`). Defaults to `None` (run from\nrepo root).",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "SourceCrate": {
      "description": "A source crate group for multi-crate extraction.",
      "properties": {
        "name": {
          "description": "Crate name (hyphens converted to underscores for rust_path).",
          "type": "string"
        },
        "sources": {
          "description": "Source files belonging to this crate.",
          "items": {
            "type": "string"
          },
          "type": "array"
        }
      },
      "required": [
        "name",
        "sources"
      ],
      "type": "object"
    },
    "StreamingConfig": {
      "anyOf": [
        {
          "description": "Legacy boolean form: `streaming = true` / `streaming = false`.",
          "type": "boolean"
        },
        {
          "$ref": "#/$defs/StreamingRecipe",
          "description": "Recipe form: `streaming = { item_type = \"Event\" }` or\n`[crates.e2e.call.streaming] item_type = \"Event\"`."
        }
      ],
      "description": "E2E streaming call recipe."
    },
    "StreamingRecipe": {
      "description": "Structured streaming recipe options.",
      "properties": {
        "enabled": {
          "default": null,
          "description": "Optional opt-in/out equivalent to the legacy boolean form.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "item_type": {
          "default": null,
          "description": "Concrete tagged-union stream item type used by event assertions.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "StringOrVec": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "items": {
            "type": "string"
          },
          "type": "array"
        }
      ],
      "description": "A value that can be either a single string or a list of strings.\n\nDeserializes from both `\"cmd\"` and `[\"cmd1\", \"cmd2\"]` in TOML/JSON."
    },
    "StubsConfig": {
      "properties": {
        "emit_docstrings": {
          "default": false,
          "description": "When true, emit Rust `///` doc comments as stub-level docstrings.\nDefault: false — ruff PYI021 flags docstrings in stub files.",
          "type": "boolean"
        },
        "output": {
          "type": "string"
        }
      },
      "required": [
        "output"
      ],
      "type": "object"
    },
    "SwiftConfig": {
      "properties": {
        "client_constructor_body": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Override the auto-generated `create_<type>(api_key, base_url)` constructor\nbody for opaque client types that expose methods. When set, the swift backend\nemits this snippet verbatim as the function body (no implicit `Ok(...)`).\n\nUse this when the source crate's constructor signature differs from the\ndefault `Type::new(api_key, base_url)` shape — e.g. some clients use\n`DefaultClient::new(ClientConfig, Option<&str>)` and needs to build a\n`ClientConfig` from the bridge inputs first.\n\nThe snippet is parameterised by `{type_name}` (the wrapper newtype name)\nand runs in a function body with `api_key: String` and `base_url: Option<String>`\nalready in scope. It must return `Result<{type_name}, String>`.",
          "type": "object"
        },
        "core_crate_override": {
          "default": null,
          "description": "Override the core Cargo dependency name and path for the Swift binding crate.\nWhen set, the binding `Cargo.toml` depends on this crate (resolved as\n`../../../crates/<override>`) instead of the umbrella `[crate.name]`.\nDefaults to unset.",
          "type": [
            "string",
            "null"
          ]
        },
        "exclude_extra_dependencies": {
          "default": [],
          "description": "Keys to subtract from the merged `extra_dependencies` set for this\nlanguage only.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "exclude_fields": {
          "default": [],
          "description": "Fields to exclude from Swift binding generation.\nFormat: `\"TypeName.field_name\"`.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "exclude_functions": {
          "default": [],
          "description": "Functions to exclude from Swift binding generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "exclude_types": {
          "default": [],
          "description": "Types to exclude from Swift binding generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "extra_dependencies": {
          "additionalProperties": true,
          "default": {},
          "description": "Extra Cargo dependencies merged into the generated Swift Rust bridge crate.",
          "type": "object"
        },
        "extra_lint_paths": {
          "default": [],
          "description": "Extra paths to append to default lint commands.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "features": {
          "default": null,
          "description": "Cargo features to enable on the binding crate.",
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "min_ios_version": {
          "default": null,
          "description": "Minimum iOS deployment target. Defaults to `template_versions::toolchain::SWIFT_MIN_IOS` when unset.",
          "type": [
            "string",
            "null"
          ]
        },
        "min_macos_version": {
          "default": null,
          "description": "Minimum macOS deployment target. Defaults to `template_versions::toolchain::SWIFT_MIN_MACOS` when unset.",
          "type": [
            "string",
            "null"
          ]
        },
        "module_name": {
          "default": null,
          "description": "Swift module name (e.g. `\"MyLibrary\"`). Defaults to PascalCase of the crate name.",
          "type": [
            "string",
            "null"
          ]
        },
        "package_name": {
          "default": null,
          "description": "Swift package name. Defaults to the module name.",
          "type": [
            "string",
            "null"
          ]
        },
        "rename_fields": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Per-field name remapping. Key is `TypeName.field_name`, value is the\ndesired binding field name. Applied after automatic keyword escaping.",
          "type": "object"
        },
        "run_wrapper": {
          "default": null,
          "description": "Prefix wrapper for default tool invocations.",
          "type": [
            "string",
            "null"
          ]
        },
        "serde_rename_all": {
          "default": null,
          "description": "Override the serde rename_all strategy for JSON field names (e.g. \"camelCase\", \"snake_case\").",
          "type": [
            "string",
            "null"
          ]
        },
        "swift_bridge_version": {
          "default": null,
          "description": "swift-bridge version. Defaults to `template_versions::cargo::SWIFT_BRIDGE` when unset.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "SyncConfig": {
      "description": "Configuration for the `sync-versions` command.",
      "properties": {
        "extra_paths": {
          "default": [],
          "description": "Extra file paths to update version in (glob patterns).",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "text_replacements": {
          "default": [],
          "description": "Arbitrary text replacements applied during version sync.",
          "items": {
            "$ref": "#/$defs/TextReplacement"
          },
          "type": "array"
        }
      },
      "type": "object"
    },
    "TestAppRunConfig": {
      "properties": {
        "before": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ],
          "description": "Command(s) to run before the main run commands; aborts on failure."
        },
        "precondition": {
          "description": "Shell command that must exit 0 for the test-app run to proceed; skip with warning on failure.",
          "type": [
            "string",
            "null"
          ]
        },
        "run": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ],
          "description": "Command(s) that install the published package into the registry-mode test\napp and exercise it (e.g. `cd test_apps/ruby && bundle install && bundle exec rspec`)."
        }
      },
      "type": "object"
    },
    "TestConfig": {
      "properties": {
        "before": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ],
          "description": "Command(s) to run before the main test commands; aborts on failure."
        },
        "command": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ],
          "description": "Command to run unit/integration tests for this language."
        },
        "coverage": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ],
          "description": "Command to run tests with coverage for this language."
        },
        "e2e": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ],
          "description": "Command to run e2e tests for this language."
        },
        "precondition": {
          "description": "Shell command that must exit 0 for test to run; skip with warning on failure.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "TextReplacement": {
      "description": "A single text replacement rule for version sync.",
      "properties": {
        "path": {
          "description": "Glob pattern for files to process.",
          "type": "string"
        },
        "replace": {
          "description": "Replacement string (may contain `{version}` placeholder).",
          "type": "string"
        },
        "search": {
          "description": "Regex pattern to search for (may contain `{version}` placeholder).",
          "type": "string"
        }
      },
      "required": [
        "path",
        "search",
        "replace"
      ],
      "type": "object"
    },
    "ToolsConfig": {
      "description": "Top-level `[tools]` config. Selects which package manager / tool variants\nthe default per-language pipeline commands target.\n\nAll fields are optional; getters return the documented default when unset.",
      "properties": {
        "node_package_manager": {
          "default": null,
          "description": "Node package manager. One of: `\"pnpm\"`, `\"npm\"`, `\"yarn\"`. Default: `\"pnpm\"`.",
          "type": [
            "string",
            "null"
          ]
        },
        "python_package_manager": {
          "default": null,
          "description": "Python package manager. One of: `\"uv\"`, `\"pip\"`, `\"poetry\"`. Default: `\"uv\"`.",
          "type": [
            "string",
            "null"
          ]
        },
        "rust_dev_tools": {
          "default": null,
          "description": "Rust dev tools installed by the Rust `setup` default.\nDefault: see [`DEFAULT_RUST_DEV_TOOLS`].",
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "TraitBridgeConfig": {
      "description": "Configuration for generating trait bridge code that allows foreign language\nobjects to implement Rust traits via FFI.",
      "properties": {
        "bind_via": {
          "$ref": "#/$defs/BridgeBinding",
          "default": "function_param",
          "description": "How the bridge attaches to the public API.\n\n- `\"function_param\"` (default): the bridge object arrives as a function argument\n  at the position of any `param_name`-matching parameter. This is the legacy mode.\n- `\"options_field\"`: the bridge object lives as a field on a configured options\n  struct that itself arrives as a function argument. Backends emit a host-language\n  field on that struct instead of a separate function parameter; the bridge object\n  is attached to `options.<field>` before the underlying core call."
        },
        "clear_fn": {
          "default": null,
          "description": "Name of the clear function to generate\n(e.g., `\"clear_ocr_backends\"`).\nOptional — when set, a host-language wrapper that removes ALL registered\nplugins of this type is emitted alongside `register_fn`. The function\ntakes no arguments and is typically used in test teardown.",
          "type": [
            "string",
            "null"
          ]
        },
        "context_type": {
          "default": null,
          "description": "IR type name of the trait's context associated type (e.g., `\"NodeContext\"`).\n\nWhen set, backends skip generic record/enum codegen for this type and instead\nemit the richer visitor-specific version. Replaces the former literal\n`\"NodeContext\"` string comparisons scattered across backends.",
          "type": [
            "string",
            "null"
          ]
        },
        "exclude_languages": {
          "default": [],
          "description": "Language backends that should NOT generate this trait bridge.\nUse backend names as they appear in `Backend::name()`, e.g. `[\"elixir\", \"wasm\"]`.\nWhen a backend's name is listed here, the bridge struct and all related code are\nomitted from that backend's output.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "ffi_skip_methods": {
          "default": [],
          "description": "Methods that the FFI backend should NOT forward through the vtable.\nThese methods fall back to the trait's default implementation.\nUseful for methods whose signatures involve trait-object references\n(`&dyn Trait`) that can't traverse the C FFI boundary.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "options_field": {
          "default": null,
          "description": "Field name on `options_type` that holds the bridge handle when\n`bind_via = \"options_field\"` (e.g., `\"visitor\"`). When omitted, defaults to\n`param_name`. Ignored when `bind_via = \"function_param\"`.",
          "type": [
            "string",
            "null"
          ]
        },
        "options_type": {
          "default": null,
          "description": "IR type name that owns the bridge field when `bind_via = \"options_field\"` (e.g.,\n`\"ConversionOptions\"`). Required in that mode; ignored otherwise.",
          "type": [
            "string",
            "null"
          ]
        },
        "param_name": {
          "default": null,
          "description": "Parameter name override — when the extractor sanitizes the type (e.g., `VisitorHandle`\nbecomes `String` because it is a type alias over `Rc<RefCell<dyn Trait>>`), use the\nparameter name instead of the IR type to detect which parameter to bridge.\n\nFor example, `param_name = \"visitor\"` ensures that a sanitized `visitor: Option<String>`\nparameter is still treated as a bridge param for this trait.",
          "type": [
            "string",
            "null"
          ]
        },
        "register_extra_args": {
          "default": null,
          "description": "Extra arguments to append to the `registry.register(arc, ...)` call.\nExample: `\"0\"` produces `registry.register(arc, 0)`.",
          "type": [
            "string",
            "null"
          ]
        },
        "register_fn": {
          "default": null,
          "description": "Name of the registration function to generate\n(e.g., `\"register_ocr_backend\"`).\nOptional — when set, a `#[pyfunction]` registration function is generated.\nWhen absent, only the wrapper struct and trait impl are emitted (per-call bridge pattern).",
          "type": [
            "string",
            "null"
          ]
        },
        "registry_getter": {
          "default": null,
          "description": "Rust path to the registry getter function\n(e.g., `\"sample_core::plugins::registry::get_ocr_backend_registry\"`).\nOptional — when set, the generated registration function inserts the bridge into a registry.",
          "type": [
            "string",
            "null"
          ]
        },
        "result_type": {
          "default": null,
          "description": "IR type name of the trait's result associated type (e.g., `\"VisitResult\"`).\n\nWhen set, backends skip generic record/enum codegen for this type and instead\nemit the richer visitor-specific version. Replaces the former literal\n`\"VisitResult\"` string comparisons scattered across backends.",
          "type": [
            "string",
            "null"
          ]
        },
        "super_trait": {
          "default": null,
          "description": "Super-trait that requires forwarding (e.g., `\"Plugin\"`).\nWhen set, the bridge generates an `impl SuperTrait for Wrapper` block.",
          "type": [
            "string",
            "null"
          ]
        },
        "trait_name": {
          "description": "Name of the Rust trait to bridge (e.g., `\"OcrBackend\"`).",
          "type": "string"
        },
        "type_alias": {
          "default": null,
          "description": "Named type alias in the IR that maps to this bridge (e.g., `\"VisitorHandle\"`).\n\nWhen a function parameter has a `TypeRef::Named` matching this alias, code\ngenerators replace the parameter type with the language-native callback object\n(e.g., `Py<PyAny>` for Python) and emit wrapping code to construct the bridge.",
          "type": [
            "string",
            "null"
          ]
        },
        "unregister_fn": {
          "default": null,
          "description": "Name of the unregister function to generate\n(e.g., `\"unregister_ocr_backend\"`).\nOptional — when set, a host-language wrapper that removes a previously\nregistered plugin from the registry is emitted alongside `register_fn`.\nThe function takes the plugin name as a string.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "required": [
        "trait_name"
      ],
      "type": "object"
    },
    "UpdateConfig": {
      "properties": {
        "before": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ],
          "description": "Command(s) to run before the main update commands; aborts on failure."
        },
        "precondition": {
          "description": "Shell command that must exit 0 for update to run; skip with warning on failure.",
          "type": [
            "string",
            "null"
          ]
        },
        "update": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ],
          "description": "Command(s) for safe dependency updates (compatible versions only)."
        },
        "upgrade": {
          "anyOf": [
            {
              "$ref": "#/$defs/StringOrVec"
            },
            {
              "type": "null"
            }
          ],
          "description": "Command(s) for aggressive updates (including incompatible/major bumps)."
        }
      },
      "type": "object"
    },
    "VendorMode": {
      "description": "How to vendor the Rust core crate into a language package.",
      "oneOf": [
        {
          "const": "core-only",
          "description": "Copy only the core crate, rewrite path dependencies.\nUsed by Ruby and Elixir.",
          "type": "string"
        },
        {
          "const": "full",
          "description": "Run `cargo vendor` for all transitive dependencies.\nUsed by R/CRAN packages.",
          "type": "string"
        },
        {
          "const": "registry",
          "description": "Rewrite workspace path-dependencies to registry version-dependencies; copy nothing.",
          "type": "string"
        },
        {
          "const": "none",
          "description": "No vendoring needed (default for most languages).",
          "type": "string"
        }
      ]
    },
    "WasmConfig": {
      "properties": {
        "core_crate_override": {
          "default": null,
          "description": "Override the core Cargo dependency name and path for the WASM binding crate.\nWhen set, the binding `Cargo.toml` depends on this crate (resolved as\n`../<override>`) instead of the umbrella `[crate.name]`. Use this to point\nthe WASM binding at a wasm-safe sub-crate while other languages keep the\nfacade. Defaults to unset.",
          "type": [
            "string",
            "null"
          ]
        },
        "crate_dir": {
          "default": null,
          "description": "Overrides the default `crates/{name}-wasm` formula for the crate directory.\nUseful when the Rust crate directory does not follow the alef convention\n(e.g., consumer strips a `-rs` suffix so actual crate dir is `crates/sample-markdown-wasm`\ninstead of `crates/sample-markdown-rs-wasm`). Used by setup, test, clean, and format tasks.",
          "type": [
            "string",
            "null"
          ]
        },
        "custom_rust_modules": {
          "default": [],
          "description": "Hand-written Rust modules to declare in the generated lib.rs with `pub mod <name>;`\nand re-export with `pub use <name>::*;`. Separate from `[custom_modules].wasm` which\nonly adds TypeScript `export *` re-exports. Use this for Rust-side dispatch/glue modules.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "env_shims": {
          "default": [],
          "description": "Wide-character C functions to shim for WASM external scanner interop.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "exclude_extra_dependencies": {
          "default": [],
          "description": "Keys to subtract from the merged `extra_dependencies` set for this\nlanguage only. Useful when `[crate.extra_dependencies]` lists sibling\ncrates that the WASM target cannot link.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "exclude_fields": {
          "additionalProperties": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "default": {},
          "description": "Per-type field exclusions for the generated From impls and binding struct.\nKey is the type name (e.g. \"ServerConfig\"), value is a list of field names to skip.\nUse when source fields are gated behind `#[cfg(not(target_arch = \"wasm32\"))]` and\ntherefore don't exist in the wasm32 compilation environment.",
          "type": "object"
        },
        "exclude_functions": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "exclude_types": {
          "default": [],
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "extra_dependencies": {
          "additionalProperties": true,
          "default": {},
          "description": "Additional Cargo dependencies for the WASM binding crate only.",
          "type": "object"
        },
        "extra_lint_paths": {
          "default": [],
          "description": "Extra paths to append to default lint commands (format, check, typecheck).",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "features": {
          "default": null,
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "languages": {
          "default": [],
          "description": "List of static-compiled languages supported by WASM.\nWhen set, e2e smoke tests will auto-skip for languages not in this list,\nemitting `.skip(\"not in WASM's static language set\")` for each unsupported language.\nThis bridges the gap between the full 305-language pack and the 8-language\nWASM build compiled with `SAMPLE_LANGUAGES=python,rust,javascript,typescript,go,html,css,json`.\nDefaults to empty (all languages assumed supported).",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "package_name": {
          "default": null,
          "description": "npm package name for the WASM package. Defaults to the Node package\nname with a trailing `-node` removed, plus `-wasm`.",
          "type": [
            "string",
            "null"
          ]
        },
        "rename_fields": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Per-field name remapping for this language. Key is `TypeName.field_name`, value is the\ndesired binding field name. Applied after automatic keyword escaping.",
          "type": "object"
        },
        "run_wrapper": {
          "default": null,
          "description": "Prefix wrapper for default tool invocations. When set, prepends this string to default\ncommands across all pipelines (lint, test, build, etc.).",
          "type": [
            "string",
            "null"
          ]
        },
        "serde_rename_all": {
          "default": null,
          "description": "Override the serde rename_all strategy for JSON field names (e.g. \"camelCase\", \"snake_case\").\nWhen set, this takes priority over the IR type-level serde_rename_all.",
          "type": [
            "string",
            "null"
          ]
        },
        "source_crate_remaps": {
          "default": [],
          "description": "Source crate names whose types are re-exported by the `core_crate_override`\ncrate. References to `<original_crate>::TypeName` in generated code are\nrewritten to `<override_crate>::TypeName`. Only meaningful when\n`core_crate_override` is set.\nExample: with `core_crate_override = \"mylib-http\"`, setting\n`source_crate_remaps = [\"mylib-core\", \"mylib\"]` rewrites\n`mylib_core::Method` and `mylib::Method` references to\n`mylib_http::Method` (assumes `mylib-http` re-exports them via\n`pub use mylib_core::*`).",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "type_overrides": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "type": "object"
        },
        "type_prefix": {
          "default": null,
          "description": "Prefix for generated type names (e.g. \"Wasm\" produces `WasmConversionOptions`).\nDefaults to `\"Wasm\"`.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "WorkspaceConfig": {
      "additionalProperties": false,
      "description": "Workspace-level configuration shared across all `[[crates]]` entries.\n\nEvery field is optional; an empty `[workspace]` section is valid and means\nevery crate uses Alef's built-in defaults (or its own per-crate values).\n\nResolution rule (highest priority first):\n1. Per-crate value on `[[crates]]`.\n2. Workspace default on `[workspace]`.\n3. Built-in default (compiled into Alef).",
      "properties": {
        "alef_version": {
          "default": null,
          "description": "Pinned alef CLI version (e.g. `\"0.13.0\"`). Used by the `install-alef`\nhelper to install the exact version this workspace expects.\n\nIn the legacy single-crate schema this lived at `version` at the top\nlevel. The new schema renames it to `[workspace] alef_version` so it\ncan never collide with any per-crate version field.",
          "type": [
            "string",
            "null"
          ]
        },
        "build_commands": {
          "additionalProperties": {
            "$ref": "#/$defs/BuildCommandConfig"
          },
          "default": {},
          "description": "Default build pipeline keyed by language code.",
          "type": "object"
        },
        "citation": {
          "anyOf": [
            {
              "$ref": "#/$defs/CitationConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Optional CITATION.cff metadata. When present, `alef sync-versions` writes\na fully rendered `CITATION.cff` at the repo root using these fields plus\nthe canonical workspace version. When absent, a hand-authored\nCITATION.cff (if any) only has its `version:` line updated."
        },
        "clean": {
          "additionalProperties": {
            "$ref": "#/$defs/CleanConfig"
          },
          "default": {},
          "description": "Default clean pipeline keyed by language code.",
          "type": "object"
        },
        "client_constructors": {
          "additionalProperties": {
            "$ref": "#/$defs/ClientConstructorConfig"
          },
          "default": {},
          "description": "Per-type custom constructors emitted by every backend that supports\nopaque handles.  Key: type name (e.g. `\"DefaultClient\"`).\nValue: [`ClientConstructorConfig`] describing params and a body template.",
          "type": "object"
        },
        "csharp": {
          "anyOf": [
            {
              "$ref": "#/$defs/CSharpConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Default C# backend settings."
        },
        "dart": {
          "anyOf": [
            {
              "$ref": "#/$defs/DartConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Default Dart backend settings."
        },
        "dto": {
          "$ref": "#/$defs/DtoConfig",
          "default": {
            "csharp": "record",
            "elixir": "struct",
            "go": "struct",
            "java": "record",
            "node": "interface",
            "php": "readonly-class",
            "python": "dataclass",
            "python_output": null,
            "r": "list",
            "ruby": "struct"
          },
          "description": "Default DTO/type generation styles per language. A per-crate `[crates.dto]`\ntable replaces this wholesale (no field-level merge)."
        },
        "elixir": {
          "anyOf": [
            {
              "$ref": "#/$defs/ElixirConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Default Elixir/Rustler backend settings."
        },
        "ffi": {
          "anyOf": [
            {
              "$ref": "#/$defs/FfiConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Default C FFI backend settings."
        },
        "format": {
          "$ref": "#/$defs/FormatConfig",
          "default": {
            "command": null,
            "enabled": true
          },
          "description": "Default post-generation formatting flags. A per-crate value replaces\nthis wholesale."
        },
        "format_overrides": {
          "additionalProperties": {
            "$ref": "#/$defs/FormatConfig"
          },
          "default": {},
          "description": "Default per-language formatting overrides (e.g., disable `mix format`\nfor elixir). Merged with per-crate `format_overrides` by language key:\nper-crate keys win wholesale; missing keys fall through to this map.\nNote: there is no field-level merge inside a single `FormatConfig`.",
          "type": "object"
        },
        "generate": {
          "$ref": "#/$defs/GenerateConfig",
          "default": {
            "async_wrappers": true,
            "bindings": true,
            "configs": true,
            "errors": true,
            "package_metadata": true,
            "public_api": true,
            "reverse_conversions": true,
            "type_conversions": true
          },
          "description": "Default generation-pass flags (which passes alef runs)."
        },
        "generate_overrides": {
          "additionalProperties": {
            "$ref": "#/$defs/GenerateConfig"
          },
          "default": {},
          "description": "Default per-language generation flag overrides. Merged with per-crate\n`generate_overrides` by language key: per-crate keys win wholesale;\nmissing keys fall through to this map.",
          "type": "object"
        },
        "generated_header": {
          "anyOf": [
            {
              "$ref": "#/$defs/GeneratedHeaderConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Default generated-file header metadata.\nPer-crate `[scaffold.generated_header]` values override this field-by-field."
        },
        "gleam": {
          "anyOf": [
            {
              "$ref": "#/$defs/GleamConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Default Gleam backend settings."
        },
        "go": {
          "anyOf": [
            {
              "$ref": "#/$defs/GoConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Default Go backend settings."
        },
        "java": {
          "anyOf": [
            {
              "$ref": "#/$defs/JavaConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Default Java backend settings."
        },
        "jni": {
          "anyOf": [
            {
              "$ref": "#/$defs/JniConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Default JNI backend settings."
        },
        "kotlin": {
          "anyOf": [
            {
              "$ref": "#/$defs/KotlinConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Default Kotlin backend settings."
        },
        "kotlin_android": {
          "anyOf": [
            {
              "$ref": "#/$defs/KotlinAndroidConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Default Kotlin Android backend settings."
        },
        "languages": {
          "default": [],
          "description": "Default list of target languages for crates that do not specify their\nown. A per-crate `languages` array overrides this entirely.",
          "items": {
            "$ref": "#/$defs/Language"
          },
          "type": "array"
        },
        "lint": {
          "additionalProperties": {
            "$ref": "#/$defs/LintConfig"
          },
          "default": {},
          "description": "Default lint pipeline keyed by language code (`\"python\"`, `\"node\"`, …).\nMerged field-wise with per-crate `[crates.lint.<lang>]`.",
          "type": "object"
        },
        "node": {
          "anyOf": [
            {
              "$ref": "#/$defs/NodeConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Default Node/N-API backend settings."
        },
        "opaque_types": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Workspace-wide opaque types — types from external crates that alef can't\nextract. Map of type name → fully-qualified Rust path. These get opaque\nwrapper structs across all language backends, in every crate that\nreferences them.",
          "type": "object"
        },
        "output_template": {
          "$ref": "#/$defs/OutputTemplate",
          "default": {
            "csharp": null,
            "dart": null,
            "elixir": null,
            "ffi": null,
            "gleam": null,
            "go": null,
            "java": null,
            "kotlin": null,
            "kotlin_android": null,
            "node": null,
            "php": null,
            "python": null,
            "r": null,
            "ruby": null,
            "swift": null,
            "wasm": null,
            "zig": null
          },
          "description": "Per-language output path templates with `{crate}` and `{lang}` placeholders.\nA per-crate explicit `[crates.output]` path always wins over the template."
        },
        "package_metadata": {
          "anyOf": [
            {
              "$ref": "#/$defs/PackageMetadataConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Centralized package metadata for generated language manifests.\nPer-crate `[crates.package_metadata]` values override this field-by-field."
        },
        "php": {
          "anyOf": [
            {
              "$ref": "#/$defs/PhpConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Default PHP backend settings."
        },
        "precommit": {
          "anyOf": [
            {
              "$ref": "#/$defs/PrecommitConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Default pre-commit scaffold metadata.\nPer-crate `[scaffold.precommit]` values override this field-by-field."
        },
        "python": {
          "anyOf": [
            {
              "$ref": "#/$defs/PythonConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Default Python backend settings."
        },
        "r": {
          "anyOf": [
            {
              "$ref": "#/$defs/RConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Default R/extendr backend settings."
        },
        "ruby": {
          "anyOf": [
            {
              "$ref": "#/$defs/RubyConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Default Ruby/Magnus backend settings."
        },
        "scaffold": {
          "anyOf": [
            {
              "$ref": "#/$defs/ScaffoldConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Default package metadata for generated manifests and README context.\nPer-crate `[scaffold]` values override this field-by-field."
        },
        "setup": {
          "additionalProperties": {
            "$ref": "#/$defs/SetupConfig"
          },
          "default": {},
          "description": "Default setup pipeline keyed by language code.",
          "type": "object"
        },
        "swift": {
          "anyOf": [
            {
              "$ref": "#/$defs/SwiftConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Default Swift backend settings."
        },
        "sync": {
          "anyOf": [
            {
              "$ref": "#/$defs/SyncConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Workspace-wide version sync rules. A per-crate publish step still runs\nindependently per crate; sync rules in this section apply globally."
        },
        "test": {
          "additionalProperties": {
            "$ref": "#/$defs/TestConfig"
          },
          "default": {},
          "description": "Default test pipeline keyed by language code.",
          "type": "object"
        },
        "tools": {
          "$ref": "#/$defs/ToolsConfig",
          "default": {
            "node_package_manager": null,
            "python_package_manager": null,
            "rust_dev_tools": null
          },
          "description": "Global package-manager and dev-tool preferences. Inherited by every\ncrate; cannot be overridden per-crate today."
        },
        "update": {
          "additionalProperties": {
            "$ref": "#/$defs/UpdateConfig"
          },
          "default": {},
          "description": "Default update pipeline keyed by language code.",
          "type": "object"
        },
        "wasm": {
          "anyOf": [
            {
              "$ref": "#/$defs/WasmConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Default WASM backend settings."
        },
        "zig": {
          "anyOf": [
            {
              "$ref": "#/$defs/ZigConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Default Zig backend settings."
        }
      },
      "type": "object"
    },
    "ZigConfig": {
      "properties": {
        "exclude_functions": {
          "default": [],
          "description": "Functions to exclude from Zig binding generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "exclude_types": {
          "default": [],
          "description": "Types to exclude from Zig binding generation.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "extra_lint_paths": {
          "default": [],
          "description": "Extra paths to append to default lint commands.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "features": {
          "default": null,
          "items": {
            "type": "string"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "languages": {
          "default": [],
          "description": "List of static-compiled languages supported by the Zig binding.\nWhen set, e2e fixtures whose `input.language` (or `input.config.language`)\nfalls outside this set are omitted from the generated test file entirely.\nThis bridges the gap between the full language pack and Zig's\nstatic-compiled grammar set (Zig does not currently dynamically load\ngrammars at runtime).\nDefaults to empty (all languages assumed supported).",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "module_name": {
          "type": [
            "string",
            "null"
          ]
        },
        "rename_fields": {
          "additionalProperties": {
            "type": "string"
          },
          "default": {},
          "description": "Per-field name remapping for this language. Key is `TypeName.field_name`, value is the\ndesired binding field name. Applied after automatic keyword escaping.",
          "type": "object"
        },
        "run_wrapper": {
          "default": null,
          "description": "Prefix wrapper for default tool invocations.",
          "type": [
            "string",
            "null"
          ]
        },
        "serde_rename_all": {
          "default": null,
          "description": "Override the serde rename_all strategy for JSON field names (e.g. \"camelCase\", \"snake_case\").\nWhen set, this takes priority over the IR type-level serde_rename_all.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    }
  },
  "$id": "https://github.com/kreuzberg-dev/alef/releases/download/v0.23.37/alef.schema.json",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "description": "JSON Schema for the JSON representation of alef.toml.",
  "properties": {
    "crates": {
      "description": "One entry per independently published binding package.",
      "items": {
        "$ref": "#/$defs/RawCrateConfig"
      },
      "type": "array"
    },
    "workspace": {
      "$ref": "#/$defs/WorkspaceConfig",
      "default": {
        "alef_version": null,
        "build_commands": {},
        "citation": null,
        "clean": {},
        "client_constructors": {},
        "csharp": null,
        "dart": null,
        "dto": {
          "csharp": "record",
          "elixir": "struct",
          "go": "struct",
          "java": "record",
          "node": "interface",
          "php": "readonly-class",
          "python": "dataclass",
          "python_output": null,
          "r": "list",
          "ruby": "struct"
        },
        "elixir": null,
        "ffi": null,
        "format": {
          "command": null,
          "enabled": true
        },
        "format_overrides": {},
        "generate": {
          "async_wrappers": true,
          "bindings": true,
          "configs": true,
          "errors": true,
          "package_metadata": true,
          "public_api": true,
          "reverse_conversions": true,
          "type_conversions": true
        },
        "generate_overrides": {},
        "generated_header": null,
        "gleam": null,
        "go": null,
        "java": null,
        "jni": null,
        "kotlin": null,
        "kotlin_android": null,
        "languages": [],
        "lint": {},
        "node": null,
        "opaque_types": {},
        "output_template": {
          "csharp": null,
          "dart": null,
          "elixir": null,
          "ffi": null,
          "gleam": null,
          "go": null,
          "java": null,
          "kotlin": null,
          "kotlin_android": null,
          "node": null,
          "php": null,
          "python": null,
          "r": null,
          "ruby": null,
          "swift": null,
          "wasm": null,
          "zig": null
        },
        "package_metadata": null,
        "php": null,
        "precommit": null,
        "python": null,
        "r": null,
        "ruby": null,
        "scaffold": null,
        "setup": {},
        "swift": null,
        "sync": null,
        "test": {},
        "tools": {
          "node_package_manager": null,
          "python_package_manager": null,
          "rust_dev_tools": null
        },
        "update": {},
        "wasm": null,
        "zig": null
      },
      "description": "Workspace-level shared defaults."
    }
  },
  "required": [
    "crates"
  ],
  "title": "Alef configuration",
  "type": "object",
  "version": "0.23.37",
  "x-alef-version": "0.23.37"
}
