# `AvroEx.Schema`
[🔗](https://github.com/beam-community/avro_ex/blob/v2.2.1/lib/avro_ex/schema.ex#L1)

# `alias`

```elixir
@type alias() :: name()
```

# `doc`

```elixir
@type doc() :: nil | String.t()
```

# `full_name`

```elixir
@type full_name() :: String.t()
```

# `json_schema`

```elixir
@type json_schema() :: String.t()
```

# `metadata`

```elixir
@type metadata() :: %{required(String.t()) => String.t()}
```

# `name`

```elixir
@type name() :: String.t()
```

# `named_type`

```elixir
@type named_type() ::
  AvroEx.Schema.Enum.t() | AvroEx.Schema.Fixed.t() | AvroEx.Schema.Record.t()
```

# `namespace`

```elixir
@type namespace() :: nil | String.t()
```

# `schema_types`

```elixir
@type schema_types() ::
  AvroEx.Schema.Array.t()
  | Enum.t()
  | AvroEx.Schema.Fixed.t()
  | AvroEx.Schema.Map.t()
  | AvroEx.Schema.Record.t()
  | AvroEx.Schema.Primitive.t()
  | AvroEx.Schema.Union.t()
  | AvroEx.Schema.Reference.t()
```

# `t`

```elixir
@type t() :: %AvroEx.Schema{
  context: AvroEx.Schema.Context.t(),
  schema: schema_types() | nil
}
```

# `encodable?`

```elixir
@spec encodable?(t(), any()) :: boolean()
```

# `encodable?`

```elixir
@spec encodable?(any(), any(), any()) :: boolean()
```

# `full_name`

```elixir
@spec full_name(schema_types() | name(), namespace()) :: nil | String.t()
```

The fully-qualified name of the type

## Examples
    iex> full_name(%Primitive{type: "string"})
    nil

    iex> full_name(%Record{name: "foo", namespace: "beam.community"})
    "beam.community.foo"

    iex> full_name(%Record{name: "foo"}, "top.level.namespace")
    "top.level.namespace.foo"

# `namespace`

```elixir
@spec namespace(schema_types(), namespace()) :: namespace()
```

The namespace of the given Schema type

## Examples
    iex> namespace(%Primitive{type: :string})
    nil

    iex> namespace(%Record{name: "MyRecord"}, "namespace")
    "namespace"

    iex> namespace(%Record{name: "MyRecord", namespace: "inner"}, "namespace")
    "inner"

    iex> namespace(%Record{name: "qualified.MyRecord", namespace: "inner"}, "namespace")
    "qualified"

# `type_name`

```elixir
@spec type_name(schema_types()) :: String.t()
```

The name of the schema type

## Examples

    iex> type_name(%Primitive{type: "string"})
    "string"

    iex> type_name(%Primitive{type: :long, metadata: %{"logicalType" => "timestamp-millis"}})
    "timestamp-millis"

    iex> type_name(%AvroEnum{name: "switch", symbols: []})
    "Enum<name=switch>"

    iex> type_name(%Array{items: %Primitive{type: "int"}})
    "Array<items=int>"

    iex> type_name(%Fixed{size: 2, name: "double"})
    "Fixed<name=double, size=2>"

    iex> type_name(%Union{possibilities: [%Primitive{type: "string"}, %Primitive{type: "int"}]})
    "Union<possibilities=string|int>"

    iex> type_name(%Record{name: "foo"})
    "Record<name=foo>"

    iex> type_name(%Reference{type: "foo"})
    "Reference<name=foo>"

---

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