# `GRPC.Status`
[🔗](https://github.com/elixir-grpc/grpc_core/blob/v1.0.1/lib/grpc/status.ex#L1)

A collection of gRPC statuses.

|  Code  |         Status           |                                            Status Message                                           |
|-------:|--------------------------|-----------------------------------------------------------------------------------------------------|
|   `0`  |  `:ok`                   |  Success                                                                                            |
|   `1`  |  `:cancelled`            |  The operation was cancelled (typically by the caller)                                              |
|   `2`  |  `:unknown`              |  Unknown error                                                                                      |
|   `3`  |  `:invalid_argument`     |  Client specified an invalid argument                                                               |
|   `4`  |  `:deadline_exceeded`    |  Deadline expired before operation could complete                                                   |
|   `5`  |  `:not_found`            |  Some requested entity (e.g., file or directory) was not found                                      |
|   `6`  |  `:already_exists`       |  Some entity that we attempted to create (e.g., file or directory) already exists                   |
|   `7`  |  `:permission_denied`    |  The caller does not have permission to execute the specified operation                             |
|   `8`  |  `:resource_exhausted`   |  Some resource has been exhausted                                                                   |
|   `9`  |  `:failed_precondition`  |  Operation was rejected because the system is not in a state required for the operation's execution |
|  `10`  |  `:aborted`              |  The operation was aborted                                                                          |
|  `11`  |  `:out_of_range`         |  Operation was attempted past the valid range                                                       |
|  `12`  |  `:unimplemented`        |  Operation is not implemented or not supported/enabled in this service                              |
|  `13`  |  `:internal`             |  Internal errors                                                                                    |
|  `14`  |  `:unavailable`          |  The service is currently unavailable                                                               |
|  `15`  |  `:data_loss`            |  Unrecoverable data loss or corruption                                                              |
|  `16`  |  `:unauthenticated`      |  The request does not have valid authentication credentials for the operation                       |

For more details, please refer to the [official gRPC docs](https://github.com/grpc/grpc/blob/master/doc/statuscodes.md)

# `t`

```elixir
@type t() :: non_neg_integer()
```

# `aborted`

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

The operation was aborted.

Typically due to a concurrency issue like sequencer check failures,
transaction aborts, etc.

# `already_exists`

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

Some entity that we attempted to create (e.g., file or directory) already exists.

# `cancelled`

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

The operation was cancelled (typically by the caller).

# `code_name`

```elixir
@spec code_name(t()) :: binary()
```

# `data_loss`

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

Unrecoverable data loss or corruption.

# `deadline_exceeded`

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

Deadline expired before operation could complete.

For operations that change the state of the system, this error may be returned
even if the operation has completed successfully. For example, a
successful response from a server could have been delayed long
enough for the deadline to expire.

# `failed_precondition`

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

Operation was rejected because the system is not in a state
required for the operation's execution.

For example, directory to be deleted may be non-empty,
an rmdir operation is applied to a non-directory, etc.

# `http_code`

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

# `internal`

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

Internal errors.

Means some invariants expected by underlying system has been broken.
If you see one of these errors, something is very broken.

# `invalid_argument`

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

Client specified an invalid argument.

Note that this differs from FAILED_PRECONDITION.
INVALID_ARGUMENT indicates arguments that are problematic regardless of
the state of the system (e.g., a malformed file name).

# `not_found`

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

Some requested entity (e.g., file or directory) was not found.

# `ok`

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

Not an error; returned on success.

# `out_of_range`

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

Operation was attempted past the valid range.

E.g., seeking or reading past end of file.

# `permission_denied`

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

The caller does not have permission to execute the specified
operation.

PERMISSION_DENIED must not be used for rejections
caused by exhausting some resource (use RESOURCE_EXHAUSTED
instead for those errors).  PERMISSION_DENIED must not be
used if the caller can not be identified (use UNAUTHENTICATED
instead for those errors).

# `resource_exhausted`

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

Some resource has been exhausted, perhaps a per-user quota, or
perhaps the entire file system is out of space.

# `status_message`

```elixir
@spec status_message(t()) :: String.t() | nil
```

# `unauthenticated`

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

The request does not have valid authentication credentials for the operation.

# `unavailable`

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

The service is currently unavailable.

This is a most likely a transient condition and may be corrected by retrying with
a backoff.

# `unimplemented`

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

Operation is not implemented or not supported/enabled in this service.

# `unknown`

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

Unknown error.

An example of where this error may be returned is
if a Status value received from another address space belongs to
an error-space that is not known in this address space. Also
errors raised by APIs that do not return enough error information
may be converted to this error.

---

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