noosh24 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 35944f68c0f36a9daebdc66211a063f21907d22b2f56f8889f9f13ec21697717
+  data.tar.gz: 00fe1188d82f3e26598a4701c09a083b5243f82caf36cefe80787880d2b3fd85
+SHA512:
+  metadata.gz: 9b30851283d807f00d366bab0ce751fef52d676a85ae2df3093bd189444cf952a6173754789e8b29874dc93188d0f18a73acae8c802505041b4a6aec0a006e03
+  data.tar.gz: 5b4491c44277a0724d676cdb6287ea892f1b2635c01e97538597b375a6e9995cdb0f6bb9c44bf4e9d68003e1d88efa95b70581d0101e4679c692205fcc3a1b2f

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Noosh24
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,197 @@
+<div align="center">
+
+<a href="https://developer.noosh24.com"><img src="https://raw.githubusercontent.com/noosh24/sdks/main/.github/assets/noosh-lockup.svg" alt="Noosh24" width="260"></a>
+
+# Noosh24 Open API for Ruby
+
+**The official Ruby client for the [Noosh24 Open API](https://developer.noosh24.com).**<br>
+Menu, reservations, orders and bills, payments and the Z-report, tables, customers, loyalty, stock and reviews of a Noosh24 venue, plus creating and cancelling reservations.
+
+<a href="https://github.com/noosh24/sdks/actions/workflows/ruby.yml"><img src="https://github.com/noosh24/sdks/actions/workflows/ruby.yml/badge.svg" alt="CI"></a> <img src="https://img.shields.io/badge/Ruby-3.3%2B-CC342D?logo=ruby&logoColor=white" alt="Ruby 3.3+"> <img src="https://img.shields.io/badge/RubyGems-noosh24-DC4A38" alt="RubyGems"> <a href="https://github.com/noosh24/sdks/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue" alt="MIT license"></a>
+
+[Developer site](https://developer.noosh24.com) · [API reference](https://developer.noosh24.com/reference) · [All SDKs](https://github.com/noosh24/sdks) · [Report an issue](https://github.com/noosh24/sdks/issues)
+
+</div>
+
+> [!IMPORTANT]
+> **Keep the API key on your server.** A key belongs to one venue and opens its data: guests' phone numbers, payments, and writing reservations. Never put it in a browser, a mobile app or a public repository.
+
+**Contents:** [Requirements](#requirements) · [Install](#install) · [Quick start](#quick-start) · [Options](#options) · [Resources](#resources) · [Lists, filters and pages](#lists-filters-and-pages) · [Reservations](#reservations) · [Errors](#errors) · [Retries and rate limits](#retries-and-rate-limits) · [Development](#development) · [License](#license)
+
+## Requirements
+
+- Ruby 3.3 or newer (tested on 3.3 and 4.0). No runtime dependencies: `net/http` and `json` from the standard library.
+- Frozen value objects (`Data`) for every response.
+
+## Install
+
+```bash
+gem install noosh24
+```
+
+or in a `Gemfile`:
+
+```ruby
+gem "noosh24", "~> 0.1"
+```
+
+## Quick start
+
+```ruby
+require "noosh24"
+
+noosh = Noosh24::Client.new(ENV.fetch("NOOSH24_API_KEY"))
+
+me = noosh.whoami
+puts me.restaurant.name, me.key.scopes.inspect
+
+page = noosh.menu.list_products(
+  where: Noosh24.where.eq("category", "Salads").eq("available", true),
+  sort: "price desc",
+  limit: 50
+)
+page.each { |product| puts "#{product.name} #{product.price}" }
+puts "#{page.total} products match"
+```
+
+The key belongs to one venue, so there is no venue parameter anywhere. Keys are issued in the Noosh24 panel; keep them on your server, never in a browser or a mobile app.
+
+## Options
+
+```ruby
+noosh = Noosh24::Client.new(
+  "nsk_...",
+  base_url: "https://open-api.noosh24.com/v1",
+  timeout: 30,
+  max_retries: 2,
+  user_agent: "acme-pos/2.1"
+)
+```
+
+`timeout` is in seconds and applies to connecting, writing and reading. `transport:` takes any object that responds to `call(request)` with a `Noosh24::Request` (`http_method`, `url`, `headers`, `body`, `timeout`) and returns a `Noosh24::Response` (`status`, `headers`, `body`); use it for proxies, custom TLS or tests. `sleep:` takes a callable that receives the seconds to wait between retries.
+
+## Resources
+
+| Group | Methods |
+| --- | --- |
+| `whoami` | the venue, the key's scopes and the venue's modules |
+| `menu` | `list_categories`, `list_products`, `iterate_products`, `get_product(id, expand:)`, `get_stop_list` |
+| `reservations` | `list`, `iterate`, `get(id)`, `availability(date, time, guests:)`, `create(...)`, `cancel(id)` |
+| `orders` | `list`, `iterate`, `get(id)`, `list_bills`, `iterate_bills`, `get_bill(id)` |
+| `payments` | `list`, `iterate`, `get(id)`, `z_report(date = nil)` |
+| `tables` | `list`, `list_halls` |
+| `customers` | `list`, `iterate`, `get(id)` |
+| `loyalty` | `get_program`, `list_cards`, `iterate_cards` |
+| `stock` | `list_ingredients`, `iterate_ingredients`, `list_moves`, `iterate_moves`, `list_stores` |
+| `reviews` | `list`, `iterate` |
+
+Responses are frozen `Data` objects (`Noosh24::Product`, `Noosh24::Reservation`, `Noosh24::Order`, ...) with snake_case readers: `product.prep_minutes`, `reservation.starts_at`. Timestamps are `Time` objects in UTC (nanoseconds kept), money is `Float` in AZN. `model.raw` holds the JSON as the API sent it, including fields this version of the SDK does not know yet. `z_report` returns the report as a frozen `Hash`.
+
+## Lists, filters and pages
+
+List methods take `limit:`, `offset:`, `sort:`, `where:` and, for products, `expand:`. They return a `Noosh24::Page` with `items`, `total`, `limit`, `offset`, `has_more?` and `next_offset`; a page is `Enumerable`.
+
+```ruby
+orders = noosh.orders.list(
+  where: "status = 'served' AND createdAt >= '2026-11-01'",
+  sort: ["createdAt desc"],
+  limit: 100
+)
+```
+
+`where` is AND only, and field names are the API's camelCase names. Build it with `Noosh24.where` so strings and dates are quoted correctly:
+
+```ruby
+condition = Noosh24.where
+                   .eq("status", "confirmed")
+                   .gte("startsAt", Time.new(2026, 11, 20, 0, 0, 0, "+04:00"))
+                   .in("zone", ["Terrace", "Chef's table"])
+```
+
+The builder has `eq`, `ne`, `gt`, `gte`, `lt`, `lte` and `in`, and takes strings, integers, floats, `true`/`false`, `Time` and `Date`.
+
+The `iterate*` methods walk every page and fetch the next page only when you reach it. Without a block they return an `Enumerator`; with a block they yield each item:
+
+```ruby
+noosh.payments.iterate(where: "createdAt >= '2026-11-01'") do |payment|
+  puts payment.amount
+end
+
+first_ten = noosh.customers.iterate.first(10)
+```
+
+`offset` stops at 10000. For bigger exports, narrow `where` by date and walk one window at a time.
+
+## Reservations
+
+```ruby
+free = noosh.reservations.availability("2026-11-20", "19:30", guests: 4)
+
+begin
+  result = noosh.reservations.create(
+    date: "2026-11-20",
+    time: "19:30",
+    guests: 4,
+    guest_name: "Aysel Məmmədova",
+    phone: "+994501234567",
+    table_id: free.tables.first.id,
+    pre_order: [Noosh24::PreOrderLine.new(item_id: "0b6f3c1e", qty: 2)],
+    external_ref: "acme-booking-991"
+  )
+rescue Noosh24::TableTakenError
+  warn "That table was just taken"
+end
+
+puts result.reservation.code, result.created? ? "created" : "already existed"
+noosh.reservations.cancel(result.reservation.id)
+```
+
+`create` also takes a `Noosh24::NewReservation` (`Noosh24::NewReservation.new(date:, time:, guests:, guest_name:, phone:, ...)`), and `date` may be a `Date`. A booking lands as `pending` and the venue confirms it. Always send `external_ref` (your own booking id): sending the same `external_ref` again returns the booking that already exists instead of making a second one, so a create is safe to retry. The client retries a create only when it carries an `external_ref`. You can cancel only bookings your key created.
+
+## Errors
+
+Every API error is a subclass of `Noosh24::APIError` with `status`, `code` (the API's `error` field), `message`, `headers` (lower-cased names) and `body`. Branch on the class or on `code`, not on the message.
+
+| `code` | Exception | Parent |
+| --- | --- | --- |
+| `validation_error` | `ValidationError` | `APIError` |
+| `no_api_key` | `NoApiKeyError` | `AuthenticationError` |
+| `invalid_api_key` | `InvalidApiKeyError` | `AuthenticationError` |
+| `insufficient_scope` | `InsufficientScopeError` | `PermissionDeniedError` |
+| `module_not_enabled` | `ModuleNotEnabledError` | `PermissionDeniedError` |
+| `venue_suspended` | `VenueSuspendedError` | `PermissionDeniedError` |
+| `not_your_reservation` | `NotYourReservationError` | `PermissionDeniedError` |
+| `not_found` | `NotFoundError` | `APIError` |
+| `table_not_found` | `TableNotFoundError` | `NotFoundError` |
+| `table_taken` | `TableTakenError` | `ConflictError` |
+| `cannot_cancel` | `CannotCancelError` | `ConflictError` |
+| `outside_hours`, `in_the_past`, `table_too_small` | `OutsideHoursError`, `InThePastError`, `TableTooSmallError` | `UnprocessableError` |
+| `rate_limit_exceeded` | `RateLimitError` (`retry_after`) | `APIError` |
+| `temporarily_unavailable` | `TemporarilyUnavailableError` | `ServerError` |
+
+All classes live under `Noosh24::`. An unknown code falls back to the class for its status (`ServerError` for any 5xx). A network failure raises `APIConnectionError`; a timeout raises `APITimeoutError` (a subclass of `APIConnectionError`). All of them extend `Noosh24::Error`, which extends `StandardError`. Bad arguments (an empty key or id, a bad `where` field or value) raise `ArgumentError`.
+
+## Retries and rate limits
+
+A key gets 600 requests a minute. On `429` and `502`/`503`/`504` the client waits (`Retry-After` when the API sends it, otherwise 0.5 s, 1 s, 2 s ...) and tries again, up to `max_retries` times. It never waits more than 60 seconds; a longer `Retry-After` is raised to you as a `RateLimitError`. Reads, cancels and creates with an `external_ref` are retried; a create without an `external_ref` is not.
+
+## Development
+
+```bash
+bundle install
+bundle exec rake test
+bundle exec rubocop
+```
+
+Without a local Ruby 3.3+:
+
+```bash
+docker run --rm -v "$PWD":/app -w /app ruby:3.3 sh -c 'bundle install && bundle exec rake'
+docker run --rm -v "$PWD":/app -w /app ruby:4.0 sh -c 'bundle install && bundle exec rake'
+```
+
+The models in `lib/noosh24/models.rb` are generated: `python3 tools/gen_ruby.py` from the repository root.
+
+## License
+
+MIT

data/lib/noosh24/client.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module Noosh24
+  Request = Data.define(:http_method, :url, :headers, :body, :timeout)
+  Response = Data.define(:status, :headers, :body)
+
+  class NetHTTPTransport
+    def call(request)
+      uri = URI(request.url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = request.timeout
+      http.read_timeout = request.timeout
+      http.write_timeout = request.timeout
+      response = http.start { |conn| conn.request(build(uri, request)) }
+      Response.new(status: response.code.to_i, headers: response.each_header.to_h, body: response.body.to_s)
+    end
+
+    private
+
+    def build(uri, request)
+      klass = request.http_method == "POST" ? Net::HTTP::Post : Net::HTTP::Get
+      message = klass.new(uri.request_uri)
+      request.headers.each { |name, value| message[name] = value }
+      message.body = request.body if request.body
+      message
+    end
+  end
+
+  class Client
+    DEFAULT_BASE_URL = "https://open-api.noosh24.com/v1"
+    RETRY_STATUSES = [429, 502, 503, 504].freeze
+    MAX_RETRY_WAIT = 60.0
+    TIMEOUT_ERRORS = [Timeout::Error, Net::OpenTimeout, Net::ReadTimeout, Net::WriteTimeout].freeze
+    CONNECTION_ERRORS = [
+      SocketError, SystemCallError, IOError, EOFError, OpenSSL::SSL::SSLError,
+      Net::HTTPBadResponse, Net::ProtocolError
+    ].freeze
+
+    attr_reader :base_url, :timeout, :max_retries, :user_agent,
+                :menu, :reservations, :orders, :payments, :tables, :customers, :loyalty, :stock, :reviews
+
+    def initialize(api_key, base_url: nil, timeout: 30, max_retries: 2, user_agent: nil, transport: nil, sleep: nil)
+      key = api_key.to_s.strip
+      raise ArgumentError, "An API key is required" if key.empty?
+
+      @api_key = key
+      @base_url = (base_url || DEFAULT_BASE_URL).to_s.sub(%r{/+\z}, "")
+      @timeout = timeout
+      @max_retries = [Integer(max_retries), 0].max
+      agent = "noosh24-ruby/#{VERSION}"
+      @user_agent = user_agent.to_s.empty? ? agent : "#{user_agent} #{agent}"
+      @transport = transport || NetHTTPTransport.new
+      @sleep = sleep || ->(seconds) { Kernel.sleep(seconds) }
+
+      @menu = Menu.new(self)
+      @reservations = Reservations.new(self)
+      @orders = Orders.new(self)
+      @payments = Payments.new(self)
+      @tables = Tables.new(self)
+      @customers = Customers.new(self)
+      @loyalty = Loyalty.new(self)
+      @stock = Stock.new(self)
+      @reviews = Reviews.new(self)
+    end
+
+    def whoami
+      _, data = request("GET", "/whoami")
+      Whoami.from_hash(data)
+    end
+
+    def inspect
+      "#<#{self.class.name} base_url=#{base_url.inspect}>"
+    end
+
+    def request(http_method, path, query: nil, body: nil, retryable: true)
+      req = Request.new(
+        http_method: http_method,
+        url: @base_url + path + self.class.query_string(query),
+        headers: headers(body),
+        body: body.nil? ? nil : JSON.generate(body),
+        timeout: @timeout
+      )
+      attempt = 0
+      loop do
+        result, wait, error = perform(req, attempt)
+        return result if error.nil?
+        raise error unless retryable && attempt < @max_retries && !wait.nil?
+
+        @sleep.call(wait)
+        attempt += 1
+      end
+    end
+
+    def self.query_string(query)
+      pairs = []
+      (query || {}).each do |name, value|
+        Array(value).each do |item|
+          next if item.nil?
+
+          pairs << "#{escape(name.to_s)}=#{escape(item.to_s)}"
+        end
+      end
+      pairs.empty? ? "" : "?#{pairs.join('&')}"
+    end
+
+    def self.escape(text)
+      text.b.gsub(/[^A-Za-z0-9\-._~]/n) { |char| format("%%%02X", char.ord) }
+    end
+
+    private
+
+    def headers(body)
+      out = {
+        "Authorization" => "Bearer #{@api_key}",
+        "Accept" => "application/json",
+        "User-Agent" => @user_agent
+      }
+      out["Content-Type"] = "application/json" unless body.nil?
+      out
+    end
+
+    def perform(req, attempt)
+      response = @transport.call(req)
+      status = response.status.to_i
+      headers = (response.headers || {}).to_h { |name, value| [name.to_s.downcase, Array(value).join(", ")] }
+      return [[status, decode(status, headers, response.body.to_s)], nil, nil] if status.between?(200, 299)
+
+      [nil, retry_wait(status, headers, attempt), APIError.from_response(status, headers, response.body.to_s)]
+    rescue APIConnectionError => e
+      [nil, backoff(attempt), e]
+    rescue *TIMEOUT_ERRORS => e
+      [nil, backoff(attempt), APITimeoutError.new("Request timed out after #{@timeout} s: #{e.message}")]
+    rescue *CONNECTION_ERRORS => e
+      [nil, backoff(attempt), APIConnectionError.new("Could not reach the Noosh24 API: #{e.message}")]
+    end
+
+    def decode(status, headers, body)
+      return nil if body.empty?
+
+      parsed = begin
+        JSON.parse(body, freeze: true)
+      rescue JSON::ParserError
+        raise APIError.new(status, nil, "The API answered with a body that is not JSON", headers, body)
+      end
+      unless parsed.is_a?(Hash) && parsed.key?("data")
+        raise APIError.new(status, nil, 'The API answered without a "data" field', headers, body)
+      end
+
+      parsed["data"]
+    end
+
+    def retry_wait(status, headers, attempt)
+      return nil unless RETRY_STATUSES.include?(status)
+
+      header = headers["retry-after"]
+      return backoff(attempt) if header.nil?
+
+      wait = Float(header, exception: false)
+      return backoff(attempt) if wait.nil?
+
+      wait = [wait, 0.0].max
+      wait <= MAX_RETRY_WAIT ? wait : nil
+    end
+
+    def backoff(attempt)
+      [8.0, 0.5 * (2**attempt)].min
+    end
+  end
+end

data/lib/noosh24/convert.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Noosh24
+  module Model
+    EMPTY = {}.freeze
+
+    attr_reader :raw
+
+    def initialize(raw: EMPTY, **fields)
+      @raw = raw
+      super(**fields)
+    end
+  end
+
+  module Convert
+    module_function
+
+    def mapping(value)
+      value.is_a?(Hash) ? value : Model::EMPTY
+    end
+
+    def str(value)
+      case value
+      when nil, Hash, Array then nil
+      when String then value
+      else value.to_s.freeze
+      end
+    end
+
+    def int(value)
+      case value
+      when Integer then value
+      when Float then value.finite? ? value.to_i : nil
+      end
+    end
+
+    def float(value)
+      case value
+      when Integer, Float then value.to_f
+      end
+    end
+
+    def bool(value)
+      case value
+      when nil, Hash, Array then nil
+      when true, false then value
+      when Numeric then !value.zero?
+      when String then !value.empty?
+      else true
+      end
+    end
+
+    def time(value)
+      return nil unless value.is_a?(String) && !value.empty?
+
+      Time.iso8601(value.strip).utc.freeze
+    rescue ArgumentError
+      nil
+    end
+
+    def strings(value)
+      return [].freeze unless value.is_a?(Array)
+
+      value.filter_map { |item| str(item) }.freeze
+    end
+
+    def floats(value)
+      return {}.freeze unless value.is_a?(Hash)
+
+      value.each_with_object({}) do |(key, item), out|
+        out[key.to_s.freeze] = item.to_f if item.is_a?(Integer) || item.is_a?(Float)
+      end.freeze
+    end
+
+    def date_param(value)
+      value.is_a?(Date) || value.is_a?(Time) ? value.strftime("%Y-%m-%d") : value.to_s
+    end
+
+    def object(value, model)
+      value.is_a?(Hash) ? model.from_hash(value) : nil
+    end
+
+    def list_of(value, model)
+      return [].freeze unless value.is_a?(Array)
+
+      value.filter_map { |item| model.from_hash(item) if item.is_a?(Hash) }.freeze
+    end
+
+    def map_of(value, model)
+      return {}.freeze unless value.is_a?(Hash)
+
+      value.each_with_object({}) do |(key, item), out|
+        out[key.to_s.freeze] = model.from_hash(item) if item.is_a?(Hash)
+      end.freeze
+    end
+  end
+end

data/lib/noosh24/errors.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Noosh24
+  class Error < StandardError; end
+
+  class APIConnectionError < Error; end
+
+  class APITimeoutError < APIConnectionError; end
+
+  class APIError < Error
+    attr_reader :status, :code, :headers, :body
+
+    def initialize(status, code, message, headers = {}, body = "")
+      super(message)
+      @status = status
+      @code = code
+      @headers = (headers || {}).to_h { |key, value| [key.to_s.downcase, value] }.freeze
+      @body = body
+    end
+
+    def inspect
+      "#<#{self.class.name} status=#{status} code=#{code.inspect} message=#{message.inspect}>"
+    end
+
+    def self.from_response(status, headers, body)
+      parsed = parse(body)
+      code = parsed["error"].is_a?(String) ? parsed["error"] : nil
+      message = parsed["message"].is_a?(String) ? parsed["message"] : ""
+      message = code || "HTTP #{status}" if message.empty?
+      klass = BY_CODE[code] || BY_STATUS[status] || (status >= 500 ? ServerError : APIError)
+      klass.new(status, code, message, headers, body)
+    end
+
+    def self.parse(body)
+      parsed = JSON.parse(body.to_s)
+      parsed.is_a?(Hash) ? parsed : {}
+    rescue JSON::ParserError
+      {}
+    end
+    private_class_method :parse
+  end
+
+  class ValidationError < APIError; end
+
+  class AuthenticationError < APIError; end
+
+  class NoApiKeyError < AuthenticationError; end
+
+  class InvalidApiKeyError < AuthenticationError; end
+
+  class PermissionDeniedError < APIError; end
+
+  class InsufficientScopeError < PermissionDeniedError; end
+
+  class ModuleNotEnabledError < PermissionDeniedError; end
+
+  class VenueSuspendedError < PermissionDeniedError; end
+
+  class NotYourReservationError < PermissionDeniedError; end
+
+  class NotFoundError < APIError; end
+
+  class TableNotFoundError < NotFoundError; end
+
+  class ConflictError < APIError; end
+
+  class TableTakenError < ConflictError; end
+
+  class CannotCancelError < ConflictError; end
+
+  class UnprocessableError < APIError; end
+
+  class OutsideHoursError < UnprocessableError; end
+
+  class InThePastError < UnprocessableError; end
+
+  class TableTooSmallError < UnprocessableError; end
+
+  class RateLimitError < APIError
+    def retry_after
+      value = headers["retry-after"]
+      return nil if value.nil?
+
+      [Float(value).to_i, 0].max
+    rescue ArgumentError, TypeError, FloatDomainError
+      nil
+    end
+  end
+
+  class ServerError < APIError; end
+
+  class TemporarilyUnavailableError < ServerError; end
+
+  class APIError
+    BY_CODE = {
+      "validation_error" => ValidationError,
+      "no_api_key" => NoApiKeyError,
+      "invalid_api_key" => InvalidApiKeyError,
+      "insufficient_scope" => InsufficientScopeError,
+      "module_not_enabled" => ModuleNotEnabledError,
+      "venue_suspended" => VenueSuspendedError,
+      "not_your_reservation" => NotYourReservationError,
+      "not_found" => NotFoundError,
+      "table_not_found" => TableNotFoundError,
+      "table_taken" => TableTakenError,
+      "cannot_cancel" => CannotCancelError,
+      "outside_hours" => OutsideHoursError,
+      "in_the_past" => InThePastError,
+      "table_too_small" => TableTooSmallError,
+      "rate_limit_exceeded" => RateLimitError,
+      "temporarily_unavailable" => TemporarilyUnavailableError
+    }.freeze
+
+    BY_STATUS = {
+      400 => ValidationError,
+      401 => AuthenticationError,
+      403 => PermissionDeniedError,
+      404 => NotFoundError,
+      409 => ConflictError,
+      422 => UnprocessableError,
+      429 => RateLimitError
+    }.freeze
+  end
+end