# `Ash.Resource.Builder`
[🔗](https://github.com/ash-project/ash/blob/v3.24.7/lib/ash/resource/builder.ex#L5)

Tools for transforming resources in DSL Transformers.

# `add_action`

```elixir
@spec add_action(
  Spark.Dsl.Builder.input(),
  type :: Ash.Resource.Actions.action_type(),
  name :: atom(),
  opts :: Keyword.t()
) :: Spark.Dsl.Builder.result()
```

Builds and adds an action

# `add_aggregate`

```elixir
@spec add_aggregate(
  Spark.Dsl.Builder.input(),
  name :: atom(),
  kind :: Ash.Query.Aggregate.kind(),
  relationship_path :: atom() | [atom()],
  opts :: Keyword.t()
) :: Spark.Dsl.Builder.result()
```

Builds and adds an aggregate to a resource

# `add_attribute`

```elixir
@spec add_attribute(
  Spark.Dsl.Builder.input(),
  name :: atom(),
  type :: Ash.Type.t(),
  opts :: Keyword.t()
) :: Spark.Dsl.Builder.result()
```

Builds and adds an attribute to a resource

# `add_calculation`

```elixir
@spec add_calculation(
  Spark.Dsl.Builder.input(),
  name :: atom(),
  type :: Ash.Type.t(),
  calculation :: module() | {module(), Keyword.t()},
  opts :: Keyword.t()
) :: Spark.Dsl.Builder.result()
```

Builds and adds a calculation to a resource

# `add_calculation_interface`

```elixir
@spec add_calculation_interface(
  Spark.Dsl.Builder.input(),
  name :: atom(),
  opts :: Keyword.t()
) :: Spark.Dsl.Builder.result()
```

Builds and adds an calculation interface to a resource

# `add_change`

```elixir
@spec add_change(
  Spark.Dsl.Builder.input(),
  ref :: module() | {module(), Keyword.t()},
  opts :: Keyword.t()
) :: Spark.Dsl.Builder.result()
```

Builds and adds a change

# `add_create_timestamp`

```elixir
@spec add_create_timestamp(
  Spark.Dsl.Builder.input(),
  name :: atom(),
  opts :: Keyword.t()
) :: Spark.Dsl.Builder.result()
```

Builds and adds a create_timestamp to a resource

# `add_identity`

```elixir
@spec add_identity(
  Spark.Dsl.Builder.input(),
  name :: atom(),
  fields :: atom() | [atom()],
  opts :: Keyword.t()
) :: Spark.Dsl.Builder.result()
```

Builds and adds an identity

# `add_interface`

```elixir
@spec add_interface(
  Spark.Dsl.Builder.input(),
  name :: atom(),
  opts :: Keyword.t()
) :: Spark.Dsl.Builder.result()
```

Builds and adds an interface to a resource

# `add_new_action`

```elixir
@spec add_new_action(
  Spark.Dsl.Builder.input(),
  type :: Ash.Resource.Actions.action_type(),
  name :: atom(),
  opts :: Keyword.t()
) :: Spark.Dsl.Builder.result()
```

Builds and adds a new action unless an action with that name already exists

# `add_new_aggregate`

```elixir
@spec add_new_aggregate(
  Spark.Dsl.Builder.input(),
  name :: atom(),
  kind :: Ash.Query.Aggregate.kind(),
  relationship_path :: atom() | [atom()],
  opts :: Keyword.t()
) :: Spark.Dsl.Builder.result()
```

Builds and adds an aggregate unless an aggregate with that name already exists

# `add_new_attribute`

```elixir
@spec add_new_attribute(
  Spark.Dsl.Builder.input(),
  name :: atom(),
  type :: Ash.Type.t(),
  opts :: Keyword.t()
) :: Spark.Dsl.Builder.result()
```

Builds and adds an attribute unless an attribute with that name already exists

# `add_new_calculation`

```elixir
@spec add_new_calculation(
  Spark.Dsl.Builder.input(),
  name :: atom(),
  type :: Ash.Type.t(),
  calculation :: module() | {module(), Keyword.t()} | Ash.Expr.t(),
  opts :: Keyword.t()
) :: Spark.Dsl.Builder.result()
```

Builds and adds a calculation unless a calculation with that name already exists

# `add_new_calculation_interface`

```elixir
@spec add_new_calculation_interface(
  Spark.Dsl.Builder.input(),
  name :: atom(),
  opts :: Keyword.t()
) :: Spark.Dsl.Builder.result()
```

Builds and adds an calculation interface unless an calculation interface with that name already exists

# `add_new_create_timestamp`

```elixir
@spec add_new_create_timestamp(
  Spark.Dsl.Builder.input(),
  name :: atom(),
  opts :: Keyword.t()
) ::
  Spark.Dsl.Builder.result()
```

Builds and adds a create_timestamp unless a create_timestamp with that name already exists

# `add_new_identity`

```elixir
@spec add_new_identity(
  Spark.Dsl.Builder.input(),
  name :: atom(),
  fields :: atom() | [atom()],
  opts :: Keyword.t()
) :: Spark.Dsl.Builder.result()
```

Builds and adds a new identity unless an identity with that name already exists

# `add_new_interface`

```elixir
@spec add_new_interface(
  Spark.Dsl.Builder.input(),
  name :: atom(),
  opts :: Keyword.t()
) :: Spark.Dsl.Builder.result()
```

Builds and adds an interface unless an interface with that name already exists

# `add_new_relationship`

```elixir
@spec add_new_relationship(
  Spark.Dsl.Builder.input(),
  type :: Ash.Resource.Relationships.type(),
  name :: atom(),
  destination :: module(),
  opts :: Keyword.t()
) :: Spark.Dsl.Builder.result()
```

Builds and adds a new relationship unless a relationship with that name already exists

# `add_new_update_timestamp`

```elixir
@spec add_new_update_timestamp(
  Spark.Dsl.Builder.input(),
  name :: atom(),
  opts :: Keyword.t()
) ::
  Spark.Dsl.Builder.result()
```

Builds and adds an update_timestamp unless an update_timestamp with that name already exists

# `add_preparation`

```elixir
@spec add_preparation(
  Spark.Dsl.Builder.input(),
  ref :: module() | {module(), Keyword.t()},
  opts :: Keyword.t()
) :: Spark.Dsl.Builder.result()
```

Builds and adds a preparation

# `add_relationship`

```elixir
@spec add_relationship(
  Spark.Dsl.Builder.input(),
  type :: Ash.Resource.Relationships.type(),
  name :: atom(),
  destination :: module(),
  opts :: Keyword.t()
) :: Spark.Dsl.Builder.result()
```

Builds and adds an action

# `add_update_timestamp`

```elixir
@spec add_update_timestamp(
  Spark.Dsl.Builder.input(),
  name :: atom(),
  opts :: Keyword.t()
) ::
  Spark.Dsl.Builder.result()
```

Builds and adds an update_timestamp

# `build_action`

```elixir
@spec build_action(
  type :: Ash.Resource.Actions.action_type(),
  name :: atom(),
  opts :: Keyword.t()
) :: {:ok, Ash.Resource.Actions.action()} | {:error, term()}
```

Builds an action

# `build_action_argument`

```elixir
@spec build_action_argument(name :: atom(), type :: Ash.Type.t(), opts :: Keyword.t()) ::
  {:ok, Ash.Resource.Actions.Argument.t()} | {:error, term()}
```

Builds an action argument

# `build_action_change`

```elixir
@spec build_action_change(change :: Ash.Resource.Change.ref(), opts :: Keyword.t()) ::
  {:ok, Ash.Resource.Change.t()} | {:error, term()}
```

Builds an action change

# `build_action_metadata`

```elixir
@spec build_action_metadata(name :: atom(), type :: Ash.Type.t(), opts :: Keyword.t()) ::
  {:ok, Ash.Resource.Actions.Metadata.t()} | {:error, term()}
```

Builds an action metadata

# `build_action_validation`

```elixir
@spec build_action_validation(
  change :: Ash.Resource.Validation.ref(),
  opts :: Keyword.t()
) ::
  {:ok, Ash.Resource.Validation.t()} | {:error, term()}
```

Builds an action validation

# `build_aggregate`

```elixir
@spec build_aggregate(
  name :: atom(),
  kind :: Ash.Query.Aggregate.kind(),
  relationship_path :: atom() | [atom()],
  opts :: Keyword.t()
) :: {:ok, Ash.Resource.Aggregate.t()} | {:error, term()}
```

Builds a calculation with the given name, type, and options

# `build_attribute`

```elixir
@spec build_attribute(name :: atom(), type :: Ash.Type.t(), opts :: Keyword.t()) ::
  {:ok, Ash.Resource.Attribute.t()} | {:error, term()}
```

Builds an attribute with the given name, type, and options

# `build_calculation`

```elixir
@spec build_calculation(
  name :: atom(),
  type :: Ash.Type.t(),
  calculation :: module() | {module(), Keyword.t()},
  opts :: Keyword.t()
) :: {:ok, Ash.Resource.Calculation.t()} | {:error, term()}
```

Builds a calculation with the given name, type, and options

# `build_calculation_argument`

```elixir
@spec build_calculation_argument(
  name :: atom(),
  type :: Ash.Type.t(),
  opts :: Keyword.t()
) ::
  {:ok, Ash.Resource.Calculation.Argument.t()} | {:error, term()}
```

Builds a calculation argument

# `build_calculation_interface`

```elixir
@spec build_calculation_interface(name :: atom(), opts :: Keyword.t()) ::
  {:ok, Ash.Resource.CalculationInterface.t()} | {:error, term()}
```

Builds an calculation interface with the given name, type, and options

# `build_change`

```elixir
@spec build_change(
  ref :: module() | {module(), Keyword.t()},
  opts :: Keyword.t()
) :: {:ok, Ash.Resource.Change.t()} | {:error, term()}
```

Builds a change

# `build_create_timestamp`

```elixir
@spec build_create_timestamp(name :: atom(), opts :: Keyword.t()) ::
  {:ok, Ash.Resource.Attribute.t()} | {:error, term()}
```

Builds an create_timestamp with the given name, type, and options

# `build_identity`

```elixir
@spec build_identity(
  name :: atom(),
  fields :: atom() | [atom()],
  opts :: Keyword.t()
) :: {:ok, Ash.Resource.Identity.t()} | {:error, term()}
```

Builds an action

# `build_interface`

```elixir
@spec build_interface(name :: atom(), opts :: Keyword.t()) ::
  {:ok, Ash.Resource.Interface.t()} | {:error, term()}
```

Builds an interface with the given name, type, and options

# `build_pagination`

```elixir
@spec build_pagination(pts :: Keyword.t()) ::
  {:ok, Ash.Resource.Actions.Read.Pagination.t()} | {:error, term()}
```

Builds a pagination object

# `build_preparation`

```elixir
@spec build_preparation(
  ref :: module() | {module(), Keyword.t()},
  opts :: Keyword.t()
) :: {:ok, Ash.Resource.Preparation.t()} | {:error, term()}
```

Builds a preparation

# `build_relationship`

```elixir
@spec build_relationship(
  type :: Ash.Resource.Relationships.type(),
  name :: atom(),
  destination :: module(),
  opts :: Keyword.t()
) :: {:ok, Ash.Resource.Relationships.relationship()} | {:error, term()}
```

Builds a relationship

# `build_update_timestamp`

```elixir
@spec build_update_timestamp(name :: atom(), opts :: Keyword.t()) ::
  {:ok, Ash.Resource.Attribute.t()} | {:error, term()}
```

Builds an update_timestamp with the given name, type, and options

# `prepend_action`

```elixir
@spec prepend_action(
  Spark.Dsl.Builder.input(),
  type :: Ash.Resource.Actions.action_type(),
  name :: atom(),
  opts :: Keyword.t()
) :: Spark.Dsl.Builder.result()
```

Builds and adds an action to the front of the actions list

---

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