# `MingaEditor.State.LSP.PendingRequests`
[🔗](https://github.com/jsmestad/minga/blob/main/lib/minga_editor/state/lsp/pending_requests.ex#L1)

Pure indexes for Editor-global LSP request correlations.

One response reference has exactly one semantic owner. Formatting keeps extra Buffer and newest indexes for cancellation while all request variants share the `by_ref` authority.

# `operation_kind`

```elixir
@type operation_kind() :: :references | :rename
```

# `position`

```elixir
@type position() :: {non_neg_integer(), non_neg_integer()}
```

# `request`

```elixir
@type request() ::
  {:response, MingaEditor.State.LSP.current_origin_response_kind(), pid(),
   pid(), non_neg_integer(), MingaEditor.State.Tab.id() | nil, position() | nil}
  | {:inlay_hint, pid(), pid(), non_neg_integer(),
     MingaEditor.State.Tab.id() | nil, non_neg_integer(), pos_integer()}
  | {:completion_result, MingaEditor.CompletionTrigger.response_role(), pid(),
     pid(), non_neg_integer(), non_neg_integer(), position()}
  | {:completion_resolve, pid(), pid(), non_neg_integer(), non_neg_integer(),
     map()}
  | {:signature_help, pid(), pid(), non_neg_integer(), position()}
  | {:hover_mouse, non_neg_integer(), non_neg_integer(), pid(),
     non_neg_integer(), non_neg_integer(), non_neg_integer()}
  | {:semantic_tokens, pid(), pid(), non_neg_integer(),
     Minga.LSP.PositionEncoding.encoding(), {[String.t()], [String.t()]}}
  | {:operation, operation_kind(), MingaEditor.State.Operation.id(),
     MingaEditor.State.Tab.id() | nil}
  | {:format, MingaEditor.State.LSP.FormatOperation.t()}
```

# `t`

```elixir
@type t() :: %MingaEditor.State.LSP.PendingRequests{
  by_ref: %{required(reference()) => request()},
  format_by_buffer: %{required(pid()) => reference()},
  newest_formats: [reference()]
}
```

# `drop_completion_requests`

```elixir
@spec drop_completion_requests(t()) :: t()
```

# `drop_format`

```elixir
@spec drop_format(t(), reference()) :: t()
```

# `fetch`

```elixir
@spec fetch(t(), reference()) :: {:ok, request()} | :error
```

# `fetch_format`

```elixir
@spec fetch_format(t(), reference()) ::
  {:ok, MingaEditor.State.LSP.FormatOperation.t()} | :error
```

# `format_active?`

```elixir
@spec format_active?(t(), reference()) :: boolean()
```

# `format_for_buffer`

```elixir
@spec format_for_buffer(t(), pid()) :: MingaEditor.State.LSP.FormatOperation.t() | nil
```

# `new`

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

# `newest_format`

```elixir
@spec newest_format(t()) :: MingaEditor.State.LSP.FormatOperation.t() | nil
```

# `take`

```elixir
@spec take(t(), reference()) :: {:ok, request(), t()} | :error
```

# `take_operations_for_tab`

```elixir
@spec take_operations_for_tab(t(), MingaEditor.State.Tab.id()) :: {[request()], t()}
```

# `track_completion_resolve`

```elixir
@spec track_completion_resolve(
  t(),
  reference(),
  pid(),
  pid(),
  non_neg_integer(),
  non_neg_integer(),
  map()
) :: {:ok, t()} | {:error, :duplicate_ref}
```

# `track_completion_result`

```elixir
@spec track_completion_result(
  t(),
  reference(),
  MingaEditor.CompletionTrigger.response_role(),
  pid(),
  pid(),
  non_neg_integer(),
  non_neg_integer(),
  position()
) :: {:ok, t()} | {:error, :duplicate_ref}
```

# `track_format`

```elixir
@spec track_format(t(), MingaEditor.State.LSP.FormatOperation.t()) ::
  {:ok, t()} | {:error, :duplicate_ref | :buffer_busy}
```

# `track_hover_mouse`

```elixir
@spec track_hover_mouse(
  t(),
  reference(),
  non_neg_integer(),
  non_neg_integer(),
  pid(),
  non_neg_integer(),
  non_neg_integer(),
  non_neg_integer()
) :: {:ok, t()} | {:error, :duplicate_ref}
```

# `track_inlay_hint`

```elixir
@spec track_inlay_hint(
  t(),
  reference(),
  pid(),
  pid(),
  non_neg_integer(),
  MingaEditor.State.Tab.id() | nil,
  non_neg_integer(),
  pos_integer()
) :: {:ok, t()} | {:error, :duplicate_ref}
```

# `track_operation`

```elixir
@spec track_operation(
  t(),
  reference(),
  operation_kind(),
  MingaEditor.State.Operation.id(),
  MingaEditor.State.Tab.id() | nil
) :: {:ok, t()} | {:error, :duplicate_ref}
```

# `track_response`

```elixir
@spec track_response(
  t(),
  reference(),
  MingaEditor.State.LSP.current_origin_response_kind(),
  pid(),
  pid(),
  non_neg_integer(),
  MingaEditor.State.Tab.id() | nil,
  {non_neg_integer(), non_neg_integer()} | nil
) :: {:ok, t()} | {:error, :duplicate_ref}
```

# `track_semantic_tokens`

```elixir
@spec track_semantic_tokens(
  t(),
  reference(),
  pid(),
  pid(),
  non_neg_integer(),
  Minga.LSP.PositionEncoding.encoding(),
  {[String.t()], [String.t()]}
) :: {:ok, t()} | {:error, :duplicate_ref}
```

# `track_signature_help`

```elixir
@spec track_signature_help(
  t(),
  reference(),
  pid(),
  pid(),
  non_neg_integer(),
  position()
) ::
  {:ok, t()} | {:error, :duplicate_ref}
```

---

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