# `Quic.Cleanup`
[🔗](https://github.com/gsmlg-dev/http_fetch/blob/v1.0.0-rc.9/apps/elixir_quic/lib/quic/cleanup.ex#L1)

Retained cleanup evidence for one exclusive standalone client endpoint.

Construct this scope before calling `Quic.client/1` with its birth lease. A
successful receipt joins every enrolled actor and the actual UDP Port. It
does not establish peer delivery or resolve an unknown operation outcome.
Handles remain readable after the observer exits, within the same VM.

# `deadline`

```elixir
@type deadline() :: {:abs_ms, integer()}
```

# `descriptor`

```elixir
@type descriptor() :: %{handle: handle(), lease: lease()}
```

# `handle`

```elixir
@opaque handle()
```

# `lease`

```elixir
@opaque lease()
```

# `permit`

```elixir
@opaque permit()
```

# `result`

```elixir
@type result() ::
  {:pending, snapshot()}
  | {:ok, terminal_snapshot(:confirmed)}
  | {:error,
     {:cleanup_unconfirmed,
      :birth_unresolved
      | :observation_cap
      | :observer_lost
      | :unsupported_native_socket}, terminal_snapshot(:unconfirmed)}
```

# `snapshot`

```elixir
@type snapshot() :: %{
  version: 1,
  scope: :exclusive_endpoint,
  generation: reference(),
  admission: :open | :closed,
  enrolled: integer(),
  down: integer(),
  unresolved_births: integer(),
  unresolved_operations: integer(),
  native_outcome: :resolved | :indeterminate,
  roles: %{
    endpoint: integer(),
    io: integer(),
    port: integer(),
    connection: integer()
  }
}
```

# `terminal_snapshot`

```elixir
@type terminal_snapshot(cleanup) :: %{
  version: 1,
  scope: :exclusive_endpoint,
  generation: reference(),
  admission: :open | :closed,
  enrolled: integer(),
  down: integer(),
  unresolved_births: integer(),
  unresolved_operations: integer(),
  native_outcome: :resolved | :indeterminate,
  roles: %{
    endpoint: integer(),
    io: integer(),
    port: integer(),
    connection: integer()
  },
  cleanup: cleanup
}
```

# `await`

```elixir
@spec await(Quic.Cleanup.Handle.t(), deadline()) :: result()
```

# `indeterminate`

Retain that the original operation's result is unknown, independently of cleanup.

# `new`

```elixir
@spec new(keyword()) ::
  {:ok, Quic.Cleanup.Handle.t(), Quic.Cleanup.Lease.t()} | {:error, term()}
```

# `operation`

Retain an operation intent before its native call; never replay an unknown call.

# `resolved`

Record a known return from the original operation producer.

# `retire`

```elixir
@spec retire(Quic.Cleanup.Lease.t(), deadline()) :: result()
```

# `status`

```elixir
@spec status(Quic.Cleanup.Handle.t()) :: result()
```

---

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