# `LatticeStripe.File`
[🔗](https://github.com/szTheory/lattice_stripe/blob/v2.2.2/lib/lattice_stripe/file.ex#L1)

Represents a file uploaded to Stripe.

> #### Name shadowing {: .warning}
>
> `alias LatticeStripe.File` shadows Elixir's built-in `File` module for the rest of
> that file, so `File.read!/1` would then resolve here and fail. Either fully qualify
> (`LatticeStripe.File.retrieve/3`) or alias under another name:
>
>     alias LatticeStripe.File, as: StripeFile

Files are created via multipart upload to `files.stripe.com` and used for
dispute evidence, identity verification, and other purposes. Files are
immutable after creation -- there is no update or delete operation.

## Upload

    binary = File.read!("evidence.pdf")
    {:ok, file} = LatticeStripe.File.create(client, %{
      "purpose" => "dispute_evidence",
      "file" => binary,
      "filename" => "evidence.pdf"
    })

## Retrieve

    {:ok, file} = LatticeStripe.File.retrieve(client, "file_abc123")

## List with Auto-Pagination

    LatticeStripe.File.stream!(client, %{"purpose" => "dispute_evidence"})
    |> Enum.take(50)

## Stripe API Reference

See the [Stripe File API](https://docs.stripe.com/api/files) for the full
object reference and available parameters.

# `t`

```elixir
@type t() :: %LatticeStripe.File{
  created: integer() | nil,
  expires_at: integer() | nil,
  extra: map(),
  filename: String.t() | nil,
  id: String.t() | nil,
  links: LatticeStripe.List.t() | nil,
  object: String.t(),
  purpose: String.t() | nil,
  size: integer() | nil,
  title: String.t() | nil,
  type: String.t() | nil,
  url: String.t() | nil
}
```

# `create`

```elixir
@spec create(LatticeStripe.Client.t(), map(), keyword()) ::
  {:ok, t()} | {:error, LatticeStripe.Error.t()}
```

Uploads a file to Stripe via multipart/form-data.

The `params` map must include `"purpose"` (string) and `"file"` (raw binary).
Optionally include `"filename"` (defaults to `"upload"`) and `"file_link_data"`.

## Examples

    binary = File.read!("evidence.pdf")
    LatticeStripe.File.create(client, %{
      "purpose" => "dispute_evidence",
      "file" => binary,
      "filename" => "evidence.pdf"
    })

# `create!`

```elixir
@spec create!(LatticeStripe.Client.t(), map(), keyword()) :: t()
```

Same as `create/3` but raises on error.

# `from_map`

```elixir
@spec from_map(map()) :: t()
```

# `list`

```elixir
@spec list(LatticeStripe.Client.t(), map(), keyword()) ::
  {:ok, LatticeStripe.Response.t()} | {:error, LatticeStripe.Error.t()}
```

Lists files with optional filters.

# `list!`

```elixir
@spec list!(LatticeStripe.Client.t(), map(), keyword()) :: LatticeStripe.Response.t()
```

Same as `list/3` but raises on error.

# `retrieve`

```elixir
@spec retrieve(LatticeStripe.Client.t(), String.t(), keyword()) ::
  {:ok, t()} | {:error, LatticeStripe.Error.t()}
```

Retrieves a file by ID.

# `retrieve!`

```elixir
@spec retrieve!(LatticeStripe.Client.t(), String.t(), keyword()) :: t()
```

Same as `retrieve/3` but raises on error.

# `stream!`

```elixir
@spec stream!(LatticeStripe.Client.t(), map(), keyword()) :: Enumerable.t()
```

Returns a lazy stream of all files, auto-paginating as needed.

---

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