# `Selecto.FieldResolver.ParameterizedParser`

Parser for parameterized joins with dot notation support.

This module handles parsing field references that include parameterized joins
using the new dot notation syntax: `table.field` and `table:param1:param2.field`

## Examples

    # Simple dot notation
    "posts.title" → %{type: :qualified, join: "posts", field: "title"}
    
    # Parameterized join with single parameter
    "posts:published.title" → %{type: :parameterized, join: "posts", field: "title", parameters: []}
    
    # Multiple parameters with type inference
    "products:electronics:25.0:true.name" → %{
      type: :parameterized, 
      join: "products", 
      field: "name",
      parameters: [
        {:string, "electronics"}, 
        {:float, 25.0}, 
        {:boolean, true}
      ]
    }

# `parameter`

```elixir
@type parameter() ::
  {:string, String.t()}
  | {:integer, integer()}
  | {:float, float()}
  | {:boolean, boolean()}
```

# `parsed_field`

```elixir
@type parsed_field() :: %{
  type: :simple | :qualified | :parameterized,
  field: String.t(),
  join: String.t() | nil,
  parameters: [parameter()] | nil
}
```

# `parse_field_reference`

```elixir
@spec parse_field_reference(String.t()) ::
  {:ok, parsed_field()} | {:error, String.t()}
```

Parse a field reference string into its components.

Supports dot notation with optional parameterized joins.

# `parse_join_with_parameters`

```elixir
@spec parse_join_with_parameters(String.t()) ::
  {String.t(), [parameter()]} | {:error, String.t()}
```

Parse parameters from a join string like "table:param1:param2"

# `parse_single_parameter`

Parse a single parameter string into a typed value.
Used for testing and debugging individual parameters.

# `validate_parameters`

```elixir
@spec validate_parameters([parameter()], [map()]) ::
  {:ok, [map()]} | {:error, String.t()}
```

Validate parsed parameters against join parameter definitions.

---

*Consult [api-reference.md](api-reference.md) for complete listing*