# `GRPC.Server.Stream`
[🔗](https://github.com/elixir-grpc/grpc_server/blob/v1.0.1/lib/grpc/server/stream.ex#L1)

A struct as an argument that servers get in rpc function definitions and use to handle headers,
send streaming replies.

Notice that you MUST use new stream returned by `GRPC.Server` as an argument to invoke next
functions defined by `GRPC.Server`.

## Fields

  * `:server`            - user defined gRPC server module
  * `:adapter`           - a server adapter module, like `GRPC.Server.Adapters.Cowboy`
  * `request_mod`        - the request module, or nil for untyped protocols
  * `response_mod`       - the response module, or nil for untyped protocols
  * `:codec`             - the codec
  * `:payload`           - the payload needed by the adapter
  * `:local`             - local data initialized by user
  * `:deadline`          - absolute monotonic-time (ms) by which the inbound request
    must complete, or `nil` when the caller set no deadline

# `access_mode`

```elixir
@type access_mode() :: :grpc | :grpcweb | :http_transcoding
```

# `t`

```elixir
@type t() :: %GRPC.Server.Stream{
  __interface__: map(),
  access_mode: access_mode(),
  adapter: atom(),
  codec: atom(),
  compressor: module() | nil,
  deadline: integer() | nil,
  endpoint: atom(),
  grpc_type: atom(),
  http_method: GRPC.Server.Router.http_method(),
  http_request_headers: map(),
  http_transcode: boolean(),
  is_preflight?: boolean(),
  local: any(),
  method_name: String.t(),
  payload: any(),
  request_id: String.t() | nil,
  request_mod: atom(),
  response_mod: atom(),
  rpc: tuple(),
  server: atom(),
  service_name: String.t()
}
```

# `remaining_ms`

```elixir
@spec remaining_ms(t()) :: non_neg_integer() | :infinity
```

Milliseconds left before the inbound deadline, or `:infinity` if the caller set none.
Clamped at 0 so an already-expired deadline never returns a negative value.

# `send_reply`

---

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