voiceml 0.7.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7644aa34cf82b78bbc8744567b54be9a00115a4715bb490da3974c28cf40f990
+  data.tar.gz: 5133a70ebe35ac5ad190fcb3f2ffb61dfe7197e697ea98bbc78dd672f6c02bfe
+SHA512:
+  metadata.gz: 3a5017e8cd3263cb6b32c8c28c8291d5e6f94b71472350fefec20362dc54dfb825195f1693344dca599bf8313cc7a1a16c7ace2d85ee9a733093ec71d1a37b33
+  data.tar.gz: cba24d62dbda0ff451f0cd1c23173bf45be879675f6afa86cb9dc3faa98a34583ef144955f180674f60d667a4fb67eab1ec189deee558df655e8d6a152ec12cd

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VoiceTel
+
+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,265 @@
+# 📞 VoiceML Ruby SDK
+
+The official Ruby client for the [VoiceML REST API](https://voicetel.com/docs/api/v0.7/voiceml/) — Twilio-compatible outbound voice and answering-machine-detection from VoiceTel, with idiomatic snake_case kwargs, structured errors, and a Twilio-compatible wire format.
+
+![Version](https://img.shields.io/badge/version-0.7.1.1-blue)
+![Ruby](https://img.shields.io/badge/ruby-3.0%2B-red)
+![License](https://img.shields.io/badge/license-MIT-green)
+![Tests](https://img.shields.io/badge/tests-65%20specs-brightgreen)
+![Gem](https://img.shields.io/badge/gem-voiceml-blue)
+
+## 📚 Table of Contents
+
+- [Features](#-features)
+- [Installation](#-installation)
+- [Quickstart](#-quickstart)
+- [Authentication](#-authentication)
+- [Resource Reference](#-resource-reference)
+- [Error Handling](#-error-handling)
+- [Pagination](#-pagination)
+- [Migration from twilio-ruby](#-migration-from-twilio-ruby)
+- [Rate Limits](#-rate-limits)
+- [Development](#-development)
+- [API Documentation](#-api-documentation)
+- [Contributors](#-contributors)
+- [Sponsors](#-sponsors)
+- [License](#-license)
+
+## ✨ Features
+
+### 🧱 Idiomatic Ruby End-to-End
+- **snake_case kwargs everywhere** — `to:`, `from:`, `machine_detection:`, `status_callback:` — automatically translated to Twilio's PascalCase wire field names internally.
+- **Resource-style API** — `client.calls.create(...)`, `client.queues.list`, `client.messages.each` — flat, predictable, no `account(sid).calls.create(...)` chain.
+- **Twilio-compatible wire shapes** — `AccountSid`, `From`, `To`, status callbacks, pagination envelopes — match what Twilio's Programmable Voice API documents, so existing Twilio client patterns map directly.
+
+### 🔁 Production-Grade Transport
+- **Automatic retry** with exponential backoff on 429 / 5xx and transport errors — honors `Retry-After` headers.
+- **Configurable timeouts** per client.
+- **HTTP Basic auth** with `AccountSid:ApiKey` — exactly what the Twilio Ruby SDK uses, so existing credentials work unchanged. Accepts the `auth_token:` keyword as an alias for migration-compatible drop-in.
+- **Structured exception hierarchy** — `RateLimitError`, `AuthenticationError`, `NotFoundError`, etc. all subclasses of `VoiceML::ApiError` you can rescue broadly or narrowly.
+
+### 📞 Complete API Coverage
+- **Calls** — originate, fetch, terminate, update + per-call recordings, streams, siprec, transcriptions, notifications, events, and the `/Calls/{sid}/Payments` lifecycle (Pay TwiML companion).
+- **Conferences** — list, fetch, end conferences, plus participants (mute / hold / kick) and conference-scoped recordings.
+- **Queues** — create, list, update, delete, peek, dequeue (front or specific member).
+- **Applications** — CRUD on stored TwiML + callback bundles.
+- **Recordings** — account-wide list, metadata fetch, audio fetch (follows S3 redirect), delete.
+- **Messages** — create, fetch, list (To/From/DateSent filters + pagination), update (Body redaction; Status=canceled), delete.
+- **IncomingPhoneNumbers** — list, fetch, update.
+- **Notifications** — fetch, list.
+- **Diagnostics** — `/health` deep probe, OpenAPI spec.
+
+### 🧪 Tested
+- **65 specs** with mocked HTTP layer (`webmock`) covering every resource and pagination edge cases — spec drift gets caught at parse time.
+- Integration smoke spec gated by env vars — safe for CI.
+
+### 📦 Clean Distribution
+- Zero codegen footprint — every byte hand-written.
+- Pure-Ruby, no native extensions.
+- Ships via [RubyGems](https://rubygems.org/gems/voiceml).
+
+## 🚀 Installation
+
+```bash
+gem install voiceml
+```
+
+Or in your `Gemfile`:
+
+```ruby
+gem 'voiceml', '~> 0.7'
+```
+
+Requires Ruby 3.0 or later.
+
+## 🏁 Quickstart
+
+```ruby
+require 'voiceml'
+
+client = VoiceML::Client.new(
+  account_sid: 'AC00000000000000000000000000000001',
+  api_key:     ENV.fetch('VOICEML_API_KEY')
+)
+
+call = client.calls.create(
+  to:                '+18005551234',
+  from:              '+18005550000',
+  url:               'https://example.com/twiml',
+  machine_detection: 'DetectMessageEnd'
+)
+
+puts call.sid, call.status
+
+client.queues.list.queues.each do |q|
+  puts "#{q.friendly_name}: #{q.current_size}"
+end
+```
+
+## 🔑 Authentication
+
+Every endpoint uses **HTTP Basic** with your `AccountSid` as the username and your per-tenant API key as the password — identical to Twilio's auth shape, so credentials issued for Twilio code work here unchanged.
+
+- **Username** = your `AccountSid` (Twilio-format `AC` + 32 hex chars).
+- **Password** = your per-tenant API key (pass as `api_key:` or, for migration-compatible drop-in, `auth_token:`).
+
+```ruby
+client = VoiceML::Client.new(account_sid: 'AC...', api_key: '...')
+client.diagnostics.health  # uses your AccountSid + key on every call
+```
+
+> Don't have credentials yet? See **[voicetel.com/docs/api/v0.7/voiceml/](https://voicetel.com/docs/api/v0.7/voiceml/)** for issuance and rotation.
+
+## 🗺️ Resource Reference
+
+| Resource | Methods | Covers |
+|---|---|---|
+| `client.calls` | originate, fetch, list, terminate, update | + per-call recordings, streams, siprec, transcriptions, notifications, events, payments |
+| `client.conferences` | list, fetch, end | participants (mute / hold / kick), conference-scoped recordings |
+| `client.queues` | create, list, update, delete | peek, dequeue (front or specific member) |
+| `client.applications` | CRUD on TwiML + callback bundles | |
+| `client.recordings` | account-wide list, metadata, audio fetch, delete | follows S3 redirect for audio |
+| `client.messages` | create, fetch, list, update, delete | To/From/DateSent filters; Body redaction; Status=canceled |
+| `client.incoming_phone_numbers` | list, fetch, update | |
+| `client.notifications` | fetch, list | |
+| `client.diagnostics` | `/health`, OpenAPI spec | |
+
+Methods accept idiomatic snake_case keyword arguments — they're translated to Twilio's PascalCase wire field names internally:
+
+```ruby
+client = VoiceML::Client.new(account_sid: 'AC...', api_key: '...')
+
+call = client.calls.create(
+  to:   '+18005551234',
+  from: '+18005550000',
+  url:  'https://example.com/twiml'
+)
+
+# On a live call, open a Pay session:
+session = client.calls.start_payment(
+  call.sid,
+  idempotency_key: 'order-482917',
+  status_callback: 'https://example.com/pay-status'
+)
+puts session.sid, session.status
+```
+
+## 🚨 Error Handling
+
+All errors inherit from `VoiceML::Error`. The `VoiceML::ApiError` family carries the HTTP status, the Twilio-compatible error code, and the parsed response body. Rescue broadly or narrowly:
+
+| Status | Exception |
+|--------|-----------|
+| 400 | `BadRequestError` |
+| 401 | `AuthenticationError` |
+| 403 | `PermissionDeniedError` |
+| 404 | `NotFoundError` |
+| 409 | `ConflictError` |
+| 410 | `GoneError` |
+| 429 | `RateLimitError` |
+| 501 | `NotImplementedAPIError` |
+| 5xx | `ServerError` |
+| other | `ApiError` |
+
+```ruby
+begin
+  client.calls.get('CA00000000000000000000000000000aaa')
+rescue VoiceML::NotFoundError => e
+  warn "That call isn't on your account: #{e.message}"
+rescue VoiceML::RateLimitError => e
+  warn "Slow down — status #{e.status_code}, code #{e.code}"
+rescue VoiceML::ApiError => e
+  warn "API error #{e.status_code}: #{e.message}"
+end
+```
+
+The Twilio-compatible error body (`code`, `message`, `more_info`, `status`) is parsed onto `error.code` / `error.message` with the raw payload on `error.body`.
+
+## 📄 Pagination
+
+List operations return a typed response with a Twilio-compatible pagination envelope (`page`, `page_size`, `next_page_uri`, `previous_page_uri`, …). For `/Calls`, `/Conferences`, `/Queues`, `/Recordings`, and `/Messages`, use the `each` helper to walk every page transparently. Block form yields each item; without a block, returns an `Enumerator`:
+
+```ruby
+# Block form — yields each Call across all pages
+client.calls.each(status: 'completed', page_size: 200) do |call|
+  process(call)
+end
+
+# Enumerator form — chain with Enumerable methods
+recent = client.messages.each(from: '+18005550000', page_size: 200).first(50)
+
+client.queues.each do |q|
+  archive(q) if q.current_size.zero?
+end
+```
+
+For other resources, page manually with `client.<resource>.list(page: n, page_size: 100)`.
+
+## 🔁 Migration from twilio-ruby
+
+The `account_sid` + auth-token pair `Twilio::REST::Client.new` validates in its constructor works unchanged here. The SDK accepts `auth_token:` as a Twilio-compatible alias for `api_key:`:
+
+```ruby
+# Before — twilio-ruby
+require 'twilio-ruby'
+client = Twilio::REST::Client.new('AC...', '<token>')
+
+# After — voiceml (Twilio-compatible)
+require 'voiceml'
+client = VoiceML::Client.new(account_sid: 'AC...', auth_token: '<api-key>')
+```
+
+Method names follow the resource map above (`client.calls.create(...)`, `client.queues.list`, …) rather than twilio-ruby's `client.api.v2010.accounts(sid).calls.create(...)` chain — flatter, fewer keystrokes, same wire format on the way out.
+
+## ⏱️ Rate Limits
+
+VoiceML applies per-tenant rate limits at the edge. The SDK automatically retries 429 responses with `Retry-After` honored, up to `max_retries` (default `2`). To bump it:
+
+```ruby
+client = VoiceML::Client.new(
+  account_sid: 'AC...',
+  api_key:     '...',
+  max_retries: 4,
+  timeout:     60
+)
+```
+
+## 🛠️ Development
+
+```bash
+git clone https://github.com/voicetel/voiceml-ruby-sdk
+cd voiceml-ruby-sdk
+bundle install
+
+# Run the full spec suite (fast, no network)
+bundle exec rspec
+
+# Run a single file
+bundle exec rspec spec/pagination_spec.rb
+
+# Build the gem
+gem build voiceml.gemspec
+```
+
+## 📖 API Documentation
+
+- **Reference docs:** [voicetel.com/docs/api/v0.7/voiceml/](https://voicetel.com/docs/api/v0.7/voiceml/)
+- **Validator:** [voicetel.com/voiceml/validator/](https://voicetel.com/voiceml/validator/)
+- **SDK catalogue:** [voicetel.com/docs/voiceml-sdks/](https://voicetel.com/docs/voiceml-sdks/)
+- **YARD comments:** every resource method carries `@param` / `@return` docs — `yard doc lib` builds them locally.
+
+## 🙌 Contributors
+
+- [Michael Mavroudis](https://github.com/mavroudis) — Lead Developer
+
+Contributions welcome. Open an issue describing the change you want to make, or send a pull request against `main`.
+
+## 💖 Sponsors
+
+| Sponsor | Contribution |
+|---------|--------------|
+| [VoiceTel Communications](https://voicetel.com) | Primary development and production hosting |
+
+## 📄 License
+
+MIT. See [LICENSE](LICENSE) and [voicetel.com/legal/](https://voicetel.com/legal/).

data/lib/voiceml/client.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative 'transport'
+require_relative 'resources/calls'
+require_relative 'resources/conferences'
+require_relative 'resources/queues'
+require_relative 'resources/applications'
+require_relative 'resources/recordings'
+require_relative 'resources/incoming_phone_numbers'
+require_relative 'resources/notifications'
+require_relative 'resources/diagnostics'
+require_relative 'resources/messages'
+
+module VoiceML
+  # Synchronous client for the VoiceML REST API.
+  #
+  # VoiceML uses HTTP Basic auth: the `account_sid` (Twilio-format `AC` + 32 hex) is the
+  # username and `api_key` is the password. Drop-in compatible with the Twilio Ruby SDK
+  # constructor signature.
+  #
+  # @example
+  #   client = VoiceML::Client.new(account_sid: 'AC...', api_key: '...')
+  #   call = client.calls.create(
+  #     to: '+18005551234',
+  #     from: '+18005550000',
+  #     url: 'https://example.com/twiml'
+  #   )
+  #   puts call.sid, call.status
+  class Client
+    attr_reader :calls, :conferences, :queues, :applications, :recordings,
+                :incoming_phone_numbers, :notifications, :diagnostics, :messages
+
+    # @param account_sid [String] Twilio-format AccountSid (`AC` + 32 hex).
+    # @param api_key     [String, nil] per-tenant API key. Pass either `api_key:` or the
+    #   Twilio-compatible alias `auth_token:` (not both — `ArgumentError` if you do).
+    # @param auth_token  [String, nil] Twilio-compatible alias for `api_key`. Lets twilio-ruby
+    #   code (`VoiceML::Client.new(account_sid: sid, auth_token: token)`) work unchanged.
+    # @param base_url    [String] server base URL. Defaults to `https://voiceml.voicetel.com`.
+    # @param timeout     [Numeric] per-request timeout in seconds. Defaults to 30.
+    # @param max_retries [Integer] retry attempts for 429/5xx and transport errors. Defaults to 2.
+    # @param user_agent  [String, nil] override the `User-Agent` header. Defaults to
+    #   `"voiceml-ruby/#{VERSION}"`.
+    def initialize(account_sid:, api_key: nil, auth_token: nil,
+                   base_url: Transport::DEFAULT_BASE_URL,
+                   timeout: Transport::DEFAULT_TIMEOUT,
+                   max_retries: Transport::DEFAULT_MAX_RETRIES,
+                   user_agent: nil, http_client: nil)
+      if !api_key.nil? && !auth_token.nil?
+        raise ArgumentError, 'pass either api_key: or auth_token:, not both'
+      end
+
+      resolved_key = api_key || auth_token
+
+      @transport = Transport.new(
+        account_sid: account_sid,
+        api_key:     resolved_key,
+        base_url:    base_url,
+        timeout:     timeout,
+        max_retries: max_retries,
+        user_agent:  user_agent,
+        http_client: http_client
+      )
+
+      @calls                  = CallsResource.new(@transport)
+      @conferences            = ConferencesResource.new(@transport)
+      @queues                 = QueuesResource.new(@transport)
+      @applications           = ApplicationsResource.new(@transport)
+      @recordings             = RecordingsResource.new(@transport)
+      @incoming_phone_numbers = IncomingPhoneNumbersResource.new(@transport)
+      @notifications          = NotificationsResource.new(@transport)
+      @diagnostics            = DiagnosticsResource.new(@transport)
+      @messages               = MessagesResource.new(@transport)
+    end
+
+    def account_sid
+      @transport.account_sid
+    end
+
+    def base_url
+      @transport.base_url
+    end
+  end
+end

data/lib/voiceml/errors.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module VoiceML
+  # Base class for every error raised by this SDK. Catch `VoiceML::Error` to handle them all.
+  class Error < StandardError; end
+
+  # Raised when the client is constructed with conflicting or missing config.
+  class ConfigurationError < Error; end
+
+  # Raised when the API returns a non-2xx response.
+  #
+  # The Twilio-compatible error body (`{ code, message, more_info, status }`) is parsed into
+  # `#code`, `#message`, and `#more_info` when present, with the raw payload exposed on
+  # `#body`. `#more_info` is the Twilio documentation URL for the error code (e.g.
+  # `https://www.twilio.com/docs/errors/20404`).
+  class ApiError < Error
+    attr_reader :status_code, :code, :body, :more_info
+
+    def initialize(message, status_code:, code: nil, body: nil, more_info: nil)
+      super(message)
+      @status_code = status_code
+      @code        = code
+      @body        = body
+      @more_info   = more_info
+    end
+  end
+
+  # HTTP 400 — the request was malformed or failed server-side validation.
+  class BadRequestError < ApiError; end
+
+  # HTTP 401 — Basic auth missing, account unknown, key wrong, or source IP not allowed.
+  class AuthenticationError < ApiError; end
+
+  # HTTP 403 — authenticated, but not allowed to perform this action.
+  class PermissionDeniedError < ApiError; end
+
+  # HTTP 404 — the resource does not exist (or belongs to a different tenant).
+  class NotFoundError < ApiError; end
+
+  # HTTP 409 — request conflicts with current resource state.
+  class ConflictError < ApiError; end
+
+  # HTTP 410 — recording audio is no longer available (no local file, no S3 key).
+  class GoneError < ApiError; end
+
+  # HTTP 429 — per-account rate limit exceeded.
+  class RateLimitError < ApiError; end
+
+  # HTTP 501 — endpoint is mounted as a stub (e.g. UserDefinedMessages).
+  class NotImplementedAPIError < ApiError; end
+
+  # HTTP 5xx — the server hit an error processing the request.
+  class ServerError < ApiError; end
+
+  # @api private
+  ERROR_CLASSES = {
+    400 => BadRequestError,
+    401 => AuthenticationError,
+    403 => PermissionDeniedError,
+    404 => NotFoundError,
+    409 => ConflictError,
+    410 => GoneError,
+    429 => RateLimitError,
+    501 => NotImplementedAPIError
+  }.freeze
+
+  # Map an HTTP status to the most specific `ApiError` subclass.
+  # @api private
+  def self.error_from_response(status_code, message, code: nil, body: nil, more_info: nil)
+    klass = ERROR_CLASSES[status_code]
+    klass ||= ServerError if status_code >= 500 && status_code < 600
+    klass ||= ApiError
+    klass.new(message, status_code: status_code, code: code, body: body, more_info: more_info)
+  end
+end

data/lib/voiceml/models/applications.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'common'
+
+module VoiceML
+  # Persistent TwiML+callback bundle dispatched by `<Dial><Application>`.
+  class Application
+    ATTRIBUTES = %w[
+      sid account_sid friendly_name api_version voice_url voice_method
+      voice_fallback_url voice_fallback_method voice_caller_id_lookup
+      status_callback status_callback_method status_callback_event
+      date_created date_updated uri
+    ].freeze
+
+    attr_reader(*ATTRIBUTES.map(&:to_sym))
+
+    def initialize(attrs = {})
+      ATTRIBUTES.each do |field|
+        value = attrs.key?(field) ? attrs[field] : attrs[field.to_sym]
+        instance_variable_set("@#{field}", value)
+      end
+    end
+
+    def self.from_hash(hash)
+      return nil if hash.nil?
+
+      new(hash)
+    end
+  end
+
+  # Paginated `GET /Applications` response.
+  class ApplicationList
+    include Pageable
+
+    attr_reader :applications
+
+    def initialize(hash = {})
+      assign_page_fields(hash)
+      @applications = (hash['applications'] || []).map { |a| Application.from_hash(a) }
+    end
+
+    def self.from_hash(hash)
+      new(hash || {})
+    end
+  end
+end

data/lib/voiceml/models/calls.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative 'common'
+
+module VoiceML
+  # A Twilio-compatible Call resource. Returned by `client.calls.create`, `client.calls.get`,
+  # `client.calls.update`, and listed in `CallList#calls`.
+  class Call
+    ATTRIBUTES = %w[
+      sid account_sid api_version to to_formatted from from_formatted
+      parent_call_sid caller_name forwarded_from status direction
+      answered_by start_time end_time duration price price_unit
+      phone_number_sid annotation group_sid queue_time trunk_sid
+      date_created date_updated uri subresource_uris
+    ].freeze
+
+    attr_reader(*ATTRIBUTES.map(&:to_sym))
+
+    def initialize(attrs = {})
+      ATTRIBUTES.each do |field|
+        value = attrs.key?(field) ? attrs[field] : attrs[field.to_sym]
+        instance_variable_set("@#{field}", value)
+      end
+    end
+
+    def self.from_hash(hash)
+      return nil if hash.nil?
+
+      new(hash)
+    end
+  end
+
+  # Paginated `GET /Calls` response.
+  class CallList
+    include Pageable
+
+    attr_reader :calls
+
+    def initialize(hash = {})
+      assign_page_fields(hash)
+      @calls = (hash['calls'] || []).map { |c| Call.from_hash(c) }
+    end
+
+    def self.from_hash(hash)
+      new(hash || {})
+    end
+  end
+end

data/lib/voiceml/models/common.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module VoiceML
+  # Twilio-compatible pagination envelope fields. Mix into list-response classes to expose
+  # `page`, `page_size`, `total`, `next_page_uri`, `previous_page_uri`, `first_page_uri`,
+  # `uri`, `num_pages`, `start`, `end`. The list items themselves are declared on each
+  # concrete subclass (`calls`, `conferences`, etc).
+  module Pageable
+    PAGE_FIELDS = %w[
+      page page_size num_pages total start end
+      first_page_uri next_page_uri previous_page_uri uri
+    ].freeze
+
+    PAGE_FIELDS.each do |field|
+      attr_reader field.to_sym
+    end
+
+    def assign_page_fields(hash)
+      PAGE_FIELDS.each do |field|
+        instance_variable_set("@#{field}", hash[field])
+      end
+    end
+  end
+
+  # Twilio-compatible error body. Surface only — the transport raises a VoiceML::ApiError
+  # subclass with this payload attached as `error.body`.
+  class ErrorBody
+    attr_reader :code, :message, :more_info, :status
+
+    def initialize(code: nil, message: nil, more_info: nil, status: nil)
+      @code      = code
+      @message   = message
+      @more_info = more_info
+      @status    = status
+    end
+
+    def self.from_hash(hash)
+      return nil if hash.nil?
+
+      new(
+        code:      hash['code'],
+        message:   hash['message'],
+        more_info: hash['more_info'],
+        status:    hash['status']
+      )
+    end
+  end
+
+  # One tripped check from the `/health` deep probe.
+  class HealthFailure
+    attr_reader :check, :detail
+
+    def initialize(check:, detail:)
+      @check  = check
+      @detail = detail
+    end
+
+    def self.from_hash(hash)
+      return nil if hash.nil?
+
+      new(check: hash['check'], detail: hash['detail'])
+    end
+  end
+end