Struct CallOverride 

pub struct CallOverride {

    pub module: Option<String>,
    pub function: Option<String>,
    pub arg_name_map: HashMap<String, String>,
    pub crate_name: Option<String>,
    pub class: Option<String>,
    pub alias: Option<String>,
    pub header: Option<String>,
    pub prefix: Option<String>,
    pub options_type: Option<String>,
    pub options_via: Option<String>,
    pub enum_fields: HashMap<String, String>,
    pub enum_module: Option<String>,
    pub result_is_simple: bool,
    pub result_is_array: bool,
    pub result_is_vec: bool,
    pub result_is_bytes: bool,
    pub result_is_option: bool,
    pub wrap_options_in_some: bool,
    pub extra_args: Vec<String>,
    pub returns_result: Option<bool>,
    pub handle_nested_types: HashMap<String, String>,
    pub handle_dict_types: HashSet<String>,
    pub handle_struct_type: Option<String>,
    pub handle_atom_list_fields: HashSet<String>,
    pub handle_config_type: Option<String>,
    pub php_client_factory: Option<String>,
    pub client_factory: Option<String>,
    pub bigint_fields: Vec<String>,
    pub cli_args: Vec<String>,
    pub cli_flags: HashMap<String, String>,
    pub result_type: Option<String>,
    pub arg_order: Vec<String>,
    pub options_ptr: bool,
    pub visitor_function: Option<String>,
}

Per-language override for function call configuration.

Fields

module: Option<String>

Override the module/import path.

function: Option<String>

Override the function name.

arg_name_map: HashMap<String, String>

Maps canonical argument names to language-specific argument names.

Used when a language binding uses a different parameter name than the canonical args list in CallConfig. For example, if the canonical arg name is doc but the Python binding uses html, specify:

[e2e.call.overrides.python]
arg_name_map = { doc = "html" }

The key is the canonical name (from args[].name) and the value is the name to use when emitting the keyword argument in generated tests.

crate_name: Option<String>

Override the crate name (Rust only).

class: Option<String>

Override the class name (Java/C# only).

alias: Option<String>

Import alias (Go only, e.g., htmd).

header: Option<String>

C header file name (C only).

prefix: Option<String>

FFI symbol prefix (C only).

options_type: Option<String>

For json_object args: the constructor to use instead of raw dict/object. E.g., “ConversionOptions” — generates ConversionOptions(**options) in Python, new ConversionOptions(options) in TypeScript.

options_via: Option<String>

How to pass json_object args: “kwargs” (default), “dict”, or “json”.

• "kwargs": construct OptionsType(key=val, ...) (requires options_type).
• "dict": pass as a plain dict/object literal {"key": "val"}.
• "json": pass via json.loads('...') / JSON.parse('...').

enum_fields: HashMap<String, String>

Maps fixture option field names to their enum type names. E.g., {"headingStyle": "HeadingStyle", "codeBlockStyle": "CodeBlockStyle"}. The generator imports these types and maps string values to enum constants.

enum_module: Option<String>

Module to import enum types from (if different from the main module). E.g., “html_to_markdown._html_to_markdown” for PyO3 native enums.

result_is_simple: bool

When true, the function returns a simple type (e.g., String) rather than a struct. Generators that would normally emit result.content (or equivalent field access) will use the result variable directly.

result_is_array: bool

When true (and combined with result_is_simple), the simple result is a slice/array type (e.g., []string in Go, Vec<String> in Rust). The Go generator uses strings.Join(value, " ") for contains assertions instead of string(value).

result_is_vec: bool

When true, the function returns Vec<T> rather than a single value. Field-path assertions are emitted as .iter().all(|r| <accessor>) so every element is checked. (Rust generator.)

result_is_bytes: bool

When true, the function returns a raw byte array (e.g., byte[] in Java, []byte in Go). Used by generators to select the correct length accessor (field .length vs method .length()).

result_is_option: bool

When true, the function returns Option<T>. The result is unwrapped before any non-is_none/is_some assertion runs; is_empty/not_empty assertions map to is_none()/is_some(). (Rust generator.)

wrap_options_in_some: bool

When true, the Rust generator wraps the json_object argument expression in Some(...).clone() to match an owned Option<T> parameter slot rather than passing &options. (Rust generator only.)

extra_args: Vec<String>

Trailing positional arguments appended verbatim after the configured args. Used when the target function takes additional positional slots (e.g. visitor) the fixture cannot supply directly. (Rust generator only.)

returns_result: Option<bool>

Per-rust override of the call-level returns_result. When set, takes precedence over CallConfig.returns_result for the Rust generator only. Useful when one binding is fallible while others are not.

handle_nested_types: HashMap<String, String>

Maps handle config field names to their Python type constructor names.

When the handle config object contains a nested dict-valued field, the generator will wrap it in the specified type using keyword arguments. E.g., {"browser": "BrowserConfig"} generates BrowserConfig(mode="auto") instead of {"mode": "auto"}.

handle_dict_types: HashSet<String>

Handle config fields whose type constructor takes a single dict argument instead of keyword arguments.

E.g., ["auth"] means AuthConfig({"type": "basic", ...}) instead of AuthConfig(type="basic", ...).

handle_struct_type: Option<String>

Elixir struct module name for the handle config argument.

When set, the generated Elixir handle config uses struct literal syntax (%Module.StructType{key: val}) instead of a plain string-keyed map. Rustler NifStruct requires a proper Elixir struct — plain maps are rejected.

E.g., "CrawlConfig" generates %Kreuzcrawl.CrawlConfig{download_assets: true}.

handle_atom_list_fields: HashSet<String>

Handle config fields whose list values are Elixir atoms (Rustler NifUnitEnum).

When a config field is a Vec<EnumType> in Rust, the Elixir side must pass a list of atoms (e.g., [:image, :document]) not strings (["image"]). List the field names here so the generator emits atom literals instead of strings.

E.g., ["asset_types"] generates asset_types: [:image] instead of ["image"].

handle_config_type: Option<String>

WASM config class name for handle args (WASM generator only).

When set, handle args are constructed using ConfigType.default() + setters instead of passing a plain JS object (which fails _assertClass validation).

E.g., "WasmCrawlConfig" generates:

const engineConfig = WasmCrawlConfig.default();
engineConfig.maxDepth = 1;
const engine = createEngine(engineConfig);

php_client_factory: Option<String>

PHP client factory method name (PHP generator only).

When set, the generated PHP test instantiates a client via ClassName::factory_method('test-key') and calls methods on the instance instead of using static facade calls.

E.g., "createClient" generates:

$client = LiterLlm::createClient('test-key');
$result = $client->chat($request);

client_factory: Option<String>

Client factory function name for instance-method languages (WASM, etc.).

When set, the generated test imports this function, creates a client, and calls API methods on the instance instead of as top-level functions.

E.g., "createClient" generates:

import { createClient } from 'pkg';
const client = createClient('test-key');
const result = await client.chat(request);

bigint_fields: Vec<String>

Fields on the options object that require BigInt() wrapping (WASM only).

wasm_bindgen maps Rust u64/i64 to JavaScript BigInt. Numeric values assigned to these setters must be wrapped with BigInt(n).

List camelCase field names, e.g.:

[e2e.call.overrides.wasm]
bigint_fields = ["maxTokens", "seed"]

cli_args: Vec<String>

Static CLI arguments appended to every invocation (brew/CLI generator only).

E.g., ["--format", "json"] appends --format json to every CLI call.

cli_flags: HashMap<String, String>

Maps fixture config field names to CLI flag names (brew/CLI generator only).

E.g., {"output_format": "--format"} generates --format <value> from the fixture’s output_format input field.

result_type: Option<String>

C FFI opaque result type name (C only).

The PascalCase name of the result struct, without the prefix. E.g., "ChatCompletionResponse" for LiterllmChatCompletionResponse*. If not set, defaults to the function name in PascalCase.

arg_order: Vec<String>

Override the argument order for this language binding.

Lists argument names from args in the order they should be passed to the target function. Useful when a language binding reorders parameters relative to the canonical args list in CallConfig.

E.g., if args = [path, mime_type, config] but the Node.js binding takes (path, config, mime_type?), specify:

[e2e.call.overrides.node]
arg_order = ["path", "config", "mime_type"]

options_ptr: bool

When true, json_object args with an options_type are passed as a pointer (*OptionsType) rather than a value. Use for Go bindings where the options parameter is *ConversionOptions (nil-able pointer) rather than a plain struct.

Absent options are passed as nil; present options are unmarshalled into a local variable and passed as &optionsVar.

visitor_function: Option<String>

Alternative function name to use when the fixture includes a visitor.

Some bindings expose two entry points: Convert(html, opts) for the plain case and ConvertWithVisitor(html, opts, visitor) when a visitor is involved. Set this to the visitor-accepting function name so the generator can pick the right symbol automatically.

E.g., "ConvertWithVisitor" makes the Go generator emit:

result, err := htmd.ConvertWithVisitor(html, nil, visitor)

instead of htmd.Convert(html, nil, visitor) (which would not compile).

Trait Implementations

impl Clone for CallOverride

fn clone(&self) -> CallOverride

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CallOverride

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for CallOverride

fn default() -> CallOverride

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CallOverride

fn deserialize<__D>( __deserializer: __D, ) -> Result<CallOverride, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CallOverride

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.