# `JSV.Builder`
[🔗](https://github.com/lud/jsv/blob/v0.18.3/lib/jsv/builder.ex#L1)

Internal logic to build raw schemas into `JSV.Root` structs.

# `buildable`

```elixir
@type buildable() :: {:resolved, resolvable()} | resolvable()
```

# `path_segment`

```elixir
@type path_segment() :: binary() | non_neg_integer() | atom() | {atom(), term()}
```

# `resolvable`

```elixir
@type resolvable() :: JSV.Resolver.resolvable()
```

# `t`

```elixir
@type t() :: %JSV.Builder{
  current_rev_path: term(),
  ns: term(),
  opts: term(),
  parent_ns: term(),
  resolver: term(),
  staged: [term()],
  vocabularies: term(),
  vocabulary_impls: term()
}
```

# `add_schema!`

```elixir
@spec add_schema!(t(), JSV.Key.t(), JSV.normal_schema()) :: t()
```

Adds a schema under the given key to the build, so that key or references to
this schema or its subschemas become buildable.

# `build!`

```elixir
@spec build!(t(), JSV.Ref.ns() | JSV.Ref.t(), JSV.Validator.validators()) ::
  {JSV.Validator.validators(), t()}
```

Builds the given root schema or reference into the given validators.

# `build_sub!`

```elixir
@spec build_sub!(JSV.normal_schema(), [path_segment()], t()) ::
  {JSV.Validator.validator(), t()} | {:error, term()}
```

Builds a subschema. Called from vocabulary modules to build nested schemas
such as in properties, if/else, items, etc.

# `ensure_resolved!`

```elixir
@spec ensure_resolved!(t(), resolvable()) :: t()
```

Ensures that the remote resource that the given reference or key points to is
fetched in the builder internal cache

# `fail`

```elixir
@spec fail(t(), term(), term()) :: no_return()
```

# `fetch_resolved!`

```elixir
@spec fetch_resolved!(t(), JSV.Key.t()) ::
  JSV.Resolver.Resolved.t() | {:alias_of, JSV.Key.t()}
```

Returns the raw schema identified by the given key. Use `ensure_resolved/2`
before if the resource may not have been fetched.

# `new`

```elixir
@spec new(keyword()) :: t()
```

Returns a new builder. Builders are not reusable ; a fresh builder must be
made for each different root schema.

# `stage_build`

```elixir
@spec stage_build(t(), buildable()) :: t()
```

Adds a new key to be built later. A key is generatlly derived from a
reference.

# `vocabulary_enabled?`

```elixir
@spec vocabulary_enabled?(t(), module()) :: boolean()
```

---

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