voicetel 2.2.10

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7c70dc67d349736fd88fd576459960103bcb4afbc7e9bb1512eb80569a7ad020
+  data.tar.gz: 6b3cb14e263751cb26e572d73cb511920af75047f84a9f4b2bb6f5bcef72550e
+SHA512:
+  metadata.gz: 011706d8c9b695a96e2ad2e8b9594f6916b268565c81ffaf2b598bd5ce3e009c4205594e525bb8fe5501b169dd1679e4934bde97a2d1fb490ec948037c2c5578
+  data.tar.gz: a1349e176f37078243b4a295ea9180c031707e529ad8f109eb3a08567526d3d0817fde73efd4fd4da65c6c4629a118b7fa38e1e80c4e9857992767233a666278

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VoiceTel Communications
+
+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,235 @@
+# 📞 VoiceTel Ruby SDK
+
+The official Ruby client for the [VoiceTel REST API](https://voicetel.com/docs/api/v2.2/) — provision numbers, place orders, validate e911, send messages, and manage your account, all with idiomatic Ruby, structured errors, and zero codegen footprint.
+
+![Version](https://img.shields.io/badge/version-2.2.10-blue)
+![Ruby](https://img.shields.io/badge/ruby-3.1%2B-red)
+![License](https://img.shields.io/badge/license-MIT-green)
+![Coverage](https://img.shields.io/badge/coverage-%E2%89%A585%25-brightgreen)
+![Gem](https://img.shields.io/badge/gem-voicetel-blue)
+
+## 📚 Table of Contents
+
+- [Features](#-features)
+- [Installation](#-installation)
+- [Quickstart](#-quickstart)
+- [Authentication](#-authentication)
+- [Resource Reference](#-resource-reference)
+- [Error Handling](#-error-handling)
+- [Rate Limits](#-rate-limits)
+- [Development](#-development)
+- [API Documentation](#-api-documentation)
+- [Contributors](#-contributors)
+- [Sponsors](#-sponsors)
+- [License](#-license)
+
+## ✨ Features
+
+### 🧱 Idiomatic Ruby End-to-End
+- **Resource-style API** — `client.numbers.list`, `client.messaging.send_message(...)`, just like the official SDKs in every other language.
+- **snake_case everywhere**, automatically camelCased on the wire so the spec's `fromNumber` / `toNumber` / `messagingBrandId` look like plain Ruby.
+- **RBS signatures** ship in `sig/` — opt into type-checking with Steep or Sorbet, or ignore them and stay dynamic.
+
+### 🔁 Production-Grade Transport
+- **Faraday 2.x** with connection pooling, persistent HTTP, and pluggable adapters.
+- **Automatic retry** on 429 / 5xx via `faraday-retry`, honoring `Retry-After`.
+- **Configurable timeouts** per client.
+- **Bearer auth** managed for you; password→key exchange handled by `client.login`.
+- **Structured ApiError** — `:rate_limit`, `:not_found`, `:conflict`, ... pattern-match on a Symbol, or call `err.rate_limit?`.
+
+### 📞 Complete API Coverage
+- **Numbers** — list, get, add, remove, route, translate, CNAM, LIDB, fax, forward, SMS, messaging campaigns, port-out PIN, account moves.
+- **Account** — profile, sub-accounts, CDRs, credits, payments, MRC, registration, password recovery.
+- **e911** — record provisioning, address validation, lookup, removal.
+- **Gateways** — list, create, update, delete, view bound numbers.
+- **Messaging** — SMS & MMS sending, message history, 10DLC brand and campaign registration, per-number messaging state.
+- **Lookups** — CNAM and LRN dips.
+- **iNumbering** — inventory search, coverage queries, number orders, port-in submissions, port-out availability checks (v2.2.10 LRN + rate-center tier fields).
+- **Support** — ticket create / read / update / delete, threaded messages, replies.
+- **ACL** — IP allowlist management with structured 409 conflict bodies.
+- **Authentication** — switch between Digest, IP-only, or hybrid modes; rotate passwords.
+
+### 🧪 Battle-Tested
+- Unit tests against a mocked HTTP layer (`webmock`), every resource method covered.
+- Read-only integration suite gated by env vars — safe for CI.
+- ≥85% line coverage via `simplecov`.
+
+## 🚀 Installation
+
+```bash
+gem install voicetel
+```
+
+Or in your `Gemfile`:
+
+```ruby
+gem "voicetel", "~> 2.2.10"
+```
+
+Requires Ruby 3.1 or later. Tested on 3.1, 3.2, 3.3, and 3.4.
+
+## 🏁 Quickstart
+
+```ruby
+require "voicetel"
+
+client = VoiceTel::Client.new
+
+# Exchange username + password for an API key (one-time per session)
+client.login(username: 1_000_000_001, password: "hunter2")
+
+me = client.account.get
+puts "Balance: $#{me['cash']}  |  Caller ID: #{me['callerId']}"
+
+# List your numbers
+client.numbers.list["numbers"].each do |n|
+  puts "#{n['number']}  route=#{n['route']}  cnam=#{n['cnam']}  sms=#{n['smsEnabled']}"
+end
+```
+
+Or, if you already have an API key:
+
+```ruby
+client = VoiceTel::Client.new(api_key: ENV.fetch("VOICETEL_API_KEY"))
+
+coverage = client.i_numbering.coverage(state: "NJ")
+coverage["coverage"].each do |bucket|
+  puts "#{bucket['npa']}-#{bucket['nxx']}: #{bucket['count']} TNs available"
+end
+```
+
+## 🔑 Authentication
+
+Every endpoint requires `Authorization: Bearer <apikey>` **except** `POST /v2.2/account/api-key`, which exchanges username + password for a fresh key. `Client#login` handles the exchange and installs the returned key on the transport.
+
+Re-fetch the API key after any password change — the old one is invalidated.
+
+> Don't have credentials yet? Get them at **[voicetel.com/docs/api/v2.2/credentials](https://voicetel.com/docs/api/v2.2/credentials/)**.
+
+```ruby
+client = VoiceTel::Client.new
+key = client.login(username: 1_000_000_001, password: "hunter2")
+# `key` is the freshly minted bearer; the client already has it installed.
+```
+
+## 🗺️ Resource Reference
+
+| Resource | Operations | Example |
+|---|---|---|
+| `client.account` | Profile, CDR, credits, payments, MRC, signup, recovery, sub-accounts | `client.account.cdr(start: t1, end_at: t2)` |
+| `client.acl` | IP allowlist (CIDR entries) | `client.acl.add(acl: [{ cidr: "1.2.3.0/24" }])` |
+| `client.authentication` | SIP/HTTP auth mode + password | `client.authentication.update(auth_type: 1)` |
+| `client.e911` | Records, address validation, provisioning | `client.e911.validate(address1: "...", city: "...", state: "NJ", zip: "07101")` |
+| `client.gateways` | Termination routes | `client.gateways.list` |
+| `client.i_numbering` | Inventory, orders, port-ins | `client.i_numbering.search_inventory(npa: 201)` |
+| `client.lookups` | CNAM & LRN dips | `client.lookups.lrn("2015551234", "2012548000")` |
+| `client.messaging` | SMS/MMS, 10DLC brands & campaigns | `client.messaging.send_message(from_number: "...", to_number: "...", text: "...")` |
+| `client.numbers` | All operations on TNs on the account | `client.numbers.assign_campaign("2015551234", campaign_id: "CABC123")` |
+| `client.support` | Tickets, replies, attachments | `client.support.create(subject: "...", message: "...")` |
+
+Every method that takes a body accepts a plain Ruby Hash with `snake_case` keys; the SDK camelCases them when serializing to JSON:
+
+```ruby
+client.messaging.send_message(
+  from_number: "2012548000",
+  to_number:   "2015551234",
+  text:        "Your code is 482917"
+)
+# → POST /v2.2/messages { "fromNumber": "2012548000", "toNumber": "2015551234", "text": "Your code is 482917" }
+
+client.numbers.assign_campaign("2015551234", campaign_id: "CABC123")
+# → PUT /v2.2/numbers/2015551234/messaging-campaign { "campaignId": "CABC123" }
+```
+
+Responses come back as Hash/Array structures with the API's native (camelCase) keys — easy to pass straight to `to_json` or pretty-print.
+
+## 🚨 Error Handling
+
+All HTTP errors raise `VoiceTel::ApiError`. The `kind` attribute is a Symbol; convenience predicates are exposed for readability:
+
+| Status | `kind`                | Predicate                |
+|--------|-----------------------|--------------------------|
+| 400    | `:bad_request`        | `err.bad_request?`       |
+| 401    | `:authentication`     | `err.authentication?`    |
+| 403    | `:permission_denied`  | `err.permission_denied?` |
+| 404    | `:not_found`          | `err.not_found?`         |
+| 409    | `:conflict`           | `err.conflict?`          |
+| 429    | `:rate_limit`         | `err.rate_limit?`        |
+| 5xx    | `:server`             | `err.server?`            |
+| other  | `:unknown`            | `err.unknown?`           |
+
+```ruby
+begin
+  client.numbers.get("9999999999")
+rescue VoiceTel::ApiError => e
+  case e.kind
+  when :not_found    then puts "Not on your account."
+  when :rate_limit   then puts "Slow down — retry suggested."
+  when :authentication then puts "Re-login: #{e.message}"
+  else raise
+  end
+end
+```
+
+`ApiError#body` preserves the parsed response payload — useful on 409 ACL conflicts, where the server returns structured `{added, removed, failed}` detail.
+
+## ⏱️ Rate Limits
+
+These endpoints are limited to **6 requests per hour per IP**:
+
+- `account/info` (`client.account.get`)
+- `account/cdr` (`client.account.cdr`)
+- `account/recurring-charges` (`client.account.recurring_charges`)
+- `account/payments` (`client.account.payments`)
+- `account/registration` (`client.account.registration`)
+- `account/api-key` (`client.login`)
+
+The SDK automatically retries 429 responses with `Retry-After` honored, up to `max_retries` (default `2`). To raise it:
+
+```ruby
+VoiceTel::Client.new(api_key: key, max_retries: 4, timeout: 60)
+```
+
+## 🛠️ Development
+
+```bash
+git clone https://github.com/voicetel/ruby-sdk
+cd ruby-sdk
+bundle install
+
+# Unit tests (fast, no network)
+bundle exec rspec
+
+# Lint
+bundle exec rubocop
+
+# Integration tests (live api.voicetel.com, read-only)
+cp .env.example .env  # fill in VOICETEL_USERNAME / VOICETEL_PASSWORD
+INTEGRATION=1 bundle exec rspec spec/integration
+
+# Build the gem
+gem build voicetel.gemspec
+```
+
+## 📖 API Documentation
+
+- **Reference docs:** [voicetel.com/docs/api/v2.2/](https://voicetel.com/docs/api/v2.2/)
+- **Interactive playground:** [voicetel.com/docs/api/v2.2/playground/](https://voicetel.com/docs/api/v2.2/playground/) — try the API in your browser without writing any code
+- **API credentials:** [voicetel.com/docs/api/v2.2/credentials/](https://voicetel.com/docs/api/v2.2/credentials/)
+- **Type signatures:** see `sig/voicetel.rbs`
+
+## 🙌 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
+
+This project is licensed under the MIT License — see the [LICENSE](LICENSE) file for details.

data/lib/voicetel/api_error.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module VoiceTel
+  # ApiError is raised on every non-2xx response (and on transport failures).
+  #
+  # `kind` is a Symbol classifying the failure so callers can pattern-match
+  # without checking HTTP status codes directly. The convenience predicates
+  # (`rate_limit?`, `not_found?`, etc.) are exposed for readability.
+  class ApiError < StandardError
+    KINDS = %i[
+      bad_request
+      authentication
+      permission_denied
+      not_found
+      conflict
+      rate_limit
+      server
+      unknown
+    ].freeze
+
+    attr_reader :kind, :status_code, :code, :body
+
+    def initialize(message, kind: :unknown, status_code: nil, code: nil, body: nil)
+      super(message)
+      @kind = kind
+      @status_code = status_code
+      @code = code
+      @body = body
+    end
+
+    # Convenience predicates — one per kind.
+    KINDS.each do |k|
+      define_method("#{k}?") { @kind == k }
+    end
+
+    def self.kind_from_status(status)
+      case status
+      when 400 then :bad_request
+      when 401 then :authentication
+      when 403 then :permission_denied
+      when 404 then :not_found
+      when 409 then :conflict
+      when 429 then :rate_limit
+      when 500..599 then :server
+      else :unknown
+      end
+    end
+
+    def self.from_response(status, code, message, body)
+      new(
+        message,
+        kind: kind_from_status(status),
+        status_code: status,
+        code: code,
+        body: body
+      )
+    end
+  end
+end

data/lib/voicetel/internal/transport.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/retry"
+require "faraday/net_http_persistent"
+require "json"
+require "securerandom"
+require "stringio"
+require "zlib"
+
+require_relative "../api_error"
+require_relative "../version"
+
+module VoiceTel
+  module Internal
+    # Transport is the low-level Faraday wrapper used by every resource service.
+    # It owns the connection, installs the bearer token, retries 429/5xx with
+    # Retry-After honored, and strips the `{status, data}` envelope from
+    # responses before returning the inner payload.
+    class Transport
+      RETRYABLE_STATUSES = [429, 500, 502, 503, 504].freeze
+
+      attr_reader :base_url, :user_agent, :timeout, :max_retries
+      attr_accessor :api_key
+
+      def initialize(base_url:, api_key: nil, timeout: 30, max_retries: 2, user_agent: nil, adapter: nil)
+        @base_url    = (base_url || VoiceTel::DEFAULT_BASE_URL).chomp("/")
+        @api_key     = api_key
+        @timeout     = timeout
+        @max_retries = max_retries
+        @user_agent  = user_agent || VoiceTel::USER_AGENT
+        @adapter     = adapter
+        @conn        = build_connection
+      end
+
+      # Perform an HTTP request. Returns the parsed inner data (envelope
+      # stripped) on success, or raises ApiError on failure. Returns nil on
+      # 204 No Content.
+      #
+      # @param method     [Symbol] one of :get, :post, :put, :patch, :delete
+      # @param path       [String] absolute path including the /v2.2 prefix
+      # @param query      [Hash, nil] query string params, snake_case keys
+      # @param body       [Hash, nil] request body, snake_case keys (translated to camelCase)
+      # @param require_auth [Boolean] false skips the bearer header
+      def request(method, path, query: nil, body: nil, require_auth: true)
+        if require_auth && (@api_key.nil? || @api_key.empty?)
+          raise ApiError.new(
+            "no api key set; call client.login(...) or pass api_key: to Client.new",
+            kind: :authentication
+          )
+        end
+
+        headers = build_headers(require_auth)
+        headers["Idempotency-Key"] = SecureRandom.uuid if %i[post put patch].include?(method)
+        response = @conn.run_request(method, path, body ? JSON.generate(camelize_keys(body)) : nil, headers) do |req|
+          req.params.update(camelize_keys(query)) if query && !query.empty?
+        end
+
+        handle_response(response)
+      rescue Faraday::TimeoutError => e
+        raise ApiError.new("voicetel: request timed out: #{e.message}", kind: :unknown)
+      rescue Faraday::ConnectionFailed => e
+        raise ApiError.new("voicetel: connection failed: #{e.message}", kind: :unknown)
+      end
+
+      # Recursively transform a Ruby snake_case key Hash/Array structure into
+      # a Hash with camelCase keys, suitable for JSON serialization. Values
+      # that are already strings/numbers/bools/nil/symbols pass through.
+      def camelize_keys(obj)
+        case obj
+        when Hash
+          obj.each_with_object({}) do |(k, v), h|
+            h[snake_to_camel(k)] = camelize_keys(v)
+          end
+        when Array
+          obj.map { |v| camelize_keys(v) }
+        else
+          obj
+        end
+      end
+
+      private
+
+      def snake_to_camel(key)
+        s = key.to_s
+        return s unless s.include?("_")
+
+        head, *rest = s.split("_")
+        head + rest.map(&:capitalize).join
+      end
+
+      def build_connection
+        Faraday.new(url: @base_url) do |f|
+          f.request :retry, retry_options
+          f.options.timeout      = @timeout
+          f.options.open_timeout = @timeout
+          f.adapter(@adapter || :net_http_persistent)
+        end
+      end
+
+      def retry_options
+        {
+          max: @max_retries,
+          interval: 0.5,
+          interval_randomness: 0.0,
+          backoff_factor: 2,
+          max_interval: 8,
+          retry_statuses: RETRYABLE_STATUSES,
+          methods: %i[get post put patch delete],
+          retry_if: ->(env, _exception) { RETRYABLE_STATUSES.include?(env.status) }
+        }
+      end
+
+      def decode_body(response)
+        raw = response.body.to_s
+        encoding = response.headers["content-encoding"] || response.headers["Content-Encoding"]
+        return raw unless encoding&.downcase&.include?("gzip")
+
+        Zlib::GzipReader.new(StringIO.new(raw)).read
+      end
+
+      def build_headers(require_auth)
+        h = {
+          "User-Agent" => @user_agent,
+          "Accept" => "application/json",
+          "Accept-Encoding" => "gzip",
+          "Content-Type" => "application/json"
+        }
+        h["Authorization"] = "Bearer #{@api_key}" if require_auth && @api_key && !@api_key.empty?
+        h
+      end
+
+      def handle_response(response)
+        status = response.status
+        raw = decode_body(response)
+
+        if status >= 200 && status < 300
+          return nil if raw.empty? || status == 204
+
+          parsed = parse_json(raw)
+          return unwrap(parsed)
+        end
+
+        raise build_error(status, raw)
+      end
+
+      def parse_json(raw)
+        return nil if raw.nil? || raw.empty?
+
+        JSON.parse(raw)
+      rescue JSON::ParserError
+        raw
+      end
+
+      def unwrap(parsed)
+        if parsed.is_a?(Hash) && parsed.key?("status") && parsed.key?("data")
+          parsed["data"]
+        else
+          parsed
+        end
+      end
+
+      def build_error(status, raw)
+        parsed = parse_json(raw)
+        code = nil
+        message = nil
+
+        if parsed.is_a?(Hash)
+          code    = parsed["code"]    || parsed["error"]
+          message = parsed["message"] || parsed["error"]
+        end
+        message ||= "HTTP #{status}"
+
+        ApiError.from_response(status, code, "voicetel: HTTP #{status}: #{message}", parsed || raw)
+      end
+    end
+  end
+end

data/lib/voicetel/resources/account.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module VoiceTel
+  module Resources
+    # AccountService — Account tag in the OpenAPI spec.
+    #
+    # Rate-limited endpoints (6 req/hour/IP, shared with Client#login):
+    # `cdr`, `recurring_charges`, `payments`, `registration`, and `info`.
+    class Account < Base
+      # GET /v2.2/account — return the authenticated account profile.
+      def get
+        @transport.request(:get, "/v2.2/account")
+      end
+
+      # PUT /v2.2/account — partial-update account settings.
+      def update(body)
+        @transport.request(:put, "/v2.2/account", body: body)
+      end
+
+      # POST /v2.2/account — create a sub-account (admin-only).
+      def add(body)
+        @transport.request(:post, "/v2.2/account", body: body)
+      end
+
+      # POST /v2.2/accounts — public sign-up flow.
+      def signup(body)
+        @transport.request(:post, "/v2.2/accounts", body: body)
+      end
+
+      # GET /v2.2/account/cdr — call detail records. Rate-limited.
+      def cdr(start: nil, end_at: nil)
+        q = compact_query("start" => start, "end" => end_at)
+        @transport.request(:get, "/v2.2/account/cdr", query: q)
+      end
+
+      # GET /v2.2/account/credits — credit history.
+      def credits
+        @transport.request(:get, "/v2.2/account/credits")
+      end
+
+      # GET /v2.2/account/recurring-charges — active monthly recurring charges. Rate-limited.
+      def recurring_charges
+        @transport.request(:get, "/v2.2/account/recurring-charges")
+      end
+
+      # GET /v2.2/account/payments — payment history. Rate-limited.
+      def payments
+        @transport.request(:get, "/v2.2/account/payments")
+      end
+
+      # GET /v2.2/account/registration — current SIP registration. Rate-limited.
+      def registration
+        @transport.request(:get, "/v2.2/account/registration")
+      end
+
+      # POST /v2.2/account/recovery — start password recovery. No auth required.
+      def recover(body)
+        @transport.request(:post, "/v2.2/account/recovery", body: body, require_auth: false)
+      end
+    end
+  end
+end

data/lib/voicetel/resources/acl.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module VoiceTel
+  module Resources
+    # AclService — manages the IP allowlist (CIDR entries).
+    #
+    # The DELETE /v2.2/acl endpoint is unusual: it returns 200 with a body
+    # (not 204). 409 conflicts include partial success/failure detail in the
+    # body — surfaced through ApiError#body so callers can inspect it.
+    class Acl < Base
+      def list
+        @transport.request(:get, "/v2.2/acl")
+      end
+
+      # body example: { acl: [{ cidr: "1.2.3.0/24" }] }
+      def add(body)
+        @transport.request(:post, "/v2.2/acl", body: body)
+      end
+
+      def remove(body)
+        @transport.request(:delete, "/v2.2/acl", body: body)
+      end
+    end
+  end
+end

data/lib/voicetel/resources/authentication.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module VoiceTel
+  module Resources
+    # AuthenticationService — SIP/HTTP authentication settings (mode + password).
+    #
+    # auth_type values: 0 = Digest, 1 = IP Auth, 2 = Digest OR IP, 3 = Digest AND IP.
+    class Authentication < Base
+      AUTH_TYPE_DIGEST         = 0
+      AUTH_TYPE_IP             = 1
+      AUTH_TYPE_DIGEST_OR_IP   = 2
+      AUTH_TYPE_DIGEST_AND_IP  = 3
+
+      def get
+        @transport.request(:get, "/v2.2/auth")
+      end
+
+      def update(body)
+        @transport.request(:put, "/v2.2/auth", body: body)
+      end
+    end
+  end
+end

data/lib/voicetel/resources/base.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module VoiceTel
+  module Resources
+    # Shared base for every resource service. Each service receives the
+    # client's transport on construction and uses it for HTTP calls. Keeping
+    # this thin lets us keep resource files focused on their endpoints.
+    class Base
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # Compact a query hash, dropping nil and empty-string values, before
+      # handing it to the transport. Some endpoints take a lot of optional
+      # filters and writing `nil` everywhere at call sites would be noisy.
+      def compact_query(hash)
+        hash.reject { |_, v| v.nil? || v == "" }
+      end
+    end
+  end
+end

data/lib/voicetel/resources/e911.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module VoiceTel
+  module Resources
+    # E911Service — provisioning, validation, lookup, removal.
+    #
+    # Note: request bodies take a 10-digit TN in `dn`; responses return the
+    # 11-digit E.164 US form (leading 1).
+    class E911 < Base
+      def list
+        @transport.request(:get, "/v2.2/e911")
+      end
+
+      def create(body)
+        @transport.request(:post, "/v2.2/e911", body: body)
+      end
+
+      def validate(body)
+        @transport.request(:post, "/v2.2/e911/validations", body: body)
+      end
+
+      def get(dn)
+        @transport.request(:get, "/v2.2/e911/#{dn}")
+      end
+
+      def provision(dn, body)
+        @transport.request(:put, "/v2.2/e911/#{dn}", body: body)
+      end
+
+      # Returns nil on 204 No Content.
+      def remove(dn)
+        @transport.request(:delete, "/v2.2/e911/#{dn}")
+      end
+    end
+  end
+end