opensms 0.1.0

data/lib/opensms/resources/suppressions.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Opensms
+  module Resources
+    # The +suppressions+ resource: numbers that must not receive messages.
+    # Accessed as +client.suppressions+.
+    class Suppressions < Base
+      # GET /v1/compliance/suppressions -> Page<Suppression>.
+      def list(params = nil, **kwargs)
+        http_page("/v1/compliance/suppressions", Models.build(merge(params, kwargs), %i[limit cursor]))
+      end
+
+      # POST /v1/compliance/suppressions -> 201 Suppression. Not auto-retried.
+      # @param params [Hash] :e164, :reason (stop_keyword|manual|complaint|invalid_number)
+      def create(params = nil, **kwargs)
+        body = Models.build(merge(params, kwargs), %i[e164 reason], required: %i[e164 reason])
+        @transport.request(:post, "/v1/compliance/suppressions", body: body)
+      end
+
+      # Bulk add. POST /v1/compliance/suppressions/import -> 201 { created:, received: }.
+      # Not auto-retried.
+      #
+      # @param items [Array<Hash>] each { e164:, reason: }
+      def import(items)
+        raise ArgumentError, "Opensms: `items` must be an Array." unless items.is_a?(Array)
+
+        body = { items: items.map { |i| Models.build(i, %i[e164 reason], required: %i[e164 reason]) } }
+        @transport.request(:post, "/v1/compliance/suppressions/import", body: body)
+      end
+
+      # DELETE /v1/compliance/suppressions/{id} -> 204.
+      # @return [nil]
+      def delete(id)
+        http_delete(path("/v1/compliance/suppressions", id!(id)))
+      end
+    end
+  end
+end

data/lib/opensms/resources/templates.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Opensms
+  module Resources
+    # The +templates+ resource: reusable message bodies with {{placeholders}}.
+    # Accessed as +client.templates+.
+    class Templates < Base
+      FIELDS = %i[name body traffic_type].freeze
+
+      # GET /v1/templates -> Page<Template>.
+      def list(params = nil, **kwargs)
+        http_page("/v1/templates", Models.build(merge(params, kwargs), %i[limit cursor]))
+      end
+
+      # POST /v1/templates -> 201 Template.
+      # @param params [Hash] :name (required), :body (required), :traffic_type
+      def create(params = nil, idempotency_key: nil, **kwargs)
+        body = Models.build(merge(params, kwargs), FIELDS, required: %i[name body])
+        @transport.request(:post, "/v1/templates", body: body, idempotency_key: idem(idempotency_key))
+      end
+
+      # GET /v1/templates/{id} -> Template.
+      def get(id)
+        http_get(path("/v1/templates", id!(id)))
+      end
+
+      # PATCH /v1/templates/{id} -> Template.
+      def update(id, params = nil, **kwargs)
+        body = Models.build(merge(params, kwargs), FIELDS)
+        @transport.request(:patch, path("/v1/templates", id!(id)), body: body)
+      end
+
+      # DELETE /v1/templates/{id} -> 204.
+      # @return [nil]
+      def delete(id)
+        http_delete(path("/v1/templates", id!(id)))
+      end
+    end
+  end
+end

data/lib/opensms/resources/wallet.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Opensms
+  module Resources
+    # The +wallet+ resource: balances, ledger and top-ups. Accessed as
+    # +client.wallet+.
+    class Wallet < Base
+      # GET /v1/wallet -> the +data+ array of balances.
+      # @return [Array<Hash>] [{ id:, currency:, balance:, reserved:, environment: }]
+      def balances
+        unwrap(http_get("/v1/wallet"))
+      end
+
+      # Ledger entries, newest first. Pages with +before+ (the smallest id
+      # already seen) instead of cursors; stop when fewer than +limit+ rows
+      # come back. GET /v1/wallet/ledger.
+      #
+      # @param params [Hash] :limit (1..200), :before
+      # @return [Array<Hash>] LedgerEntry list
+      def ledger(params = nil, **kwargs)
+        unwrap(http_get("/v1/wallet/ledger", Models.build(merge(params, kwargs), %i[limit before])))
+      end
+
+      # Start a payment-provider top-up (live keys only).
+      # POST /v1/wallet/topups -> 201 { id:, reference:, authorization_url:, ... }.
+      #
+      # @param params [Hash] :amount (decimal string), :currency, :channel
+      #   (card|mobile_money|bank_transfer), :email
+      def create_topup(params = nil, idempotency_key: nil, **kwargs)
+        fields = %i[amount currency channel email]
+        body = Models.build(merge(params, kwargs), fields, required: fields)
+        @transport.request(:post, "/v1/wallet/topups", body: body, idempotency_key: idem(idempotency_key))
+      end
+
+      private
+
+      def unwrap(body)
+        body.is_a?(Hash) ? (body[:data] || []) : body
+      end
+    end
+  end
+end

data/lib/opensms/resources/webhooks.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../webhook"
+
+module Opensms
+  module Resources
+    # The +webhooks+ resource: endpoints, deliveries, replays and signature
+    # verification. Accessed as +client.webhooks+.
+    class Webhooks < Base
+      # GET /v1/webhooks -> Page<Endpoint>.
+      def list(params = nil, **kwargs)
+        http_page("/v1/webhooks", Models.build(merge(params, kwargs), %i[limit cursor]))
+      end
+
+      # POST /v1/webhooks -> 201 Endpoint. The response carries +secret+
+      # (whsec_...) exactly once: store it.
+      #
+      # @param params [Hash] :url (https, required), :events (required), :enabled
+      def create(params = nil, idempotency_key: nil, **kwargs)
+        body = Models.build(merge(params, kwargs), %i[url events enabled], required: %i[url events])
+        @transport.request(:post, "/v1/webhooks", body: body, idempotency_key: idem(idempotency_key))
+      end
+
+      # GET /v1/webhooks/{id} -> Endpoint (no secret).
+      def get(id)
+        http_get(path("/v1/webhooks", id!(id)))
+      end
+
+      # Full replacement. PUT /v1/webhooks/{id} -> Endpoint.
+      #
+      # @param params [Hash] :url, :events, :enabled (all required)
+      def update(id, params = nil, idempotency_key: nil, **kwargs)
+        body = Models.build(merge(params, kwargs), %i[url events enabled], required: %i[url events enabled])
+        @transport.request(:put, path("/v1/webhooks", id!(id)), body: body, idempotency_key: idem(idempotency_key))
+      end
+
+      # DELETE /v1/webhooks/{id} -> 204.
+      # @return [nil]
+      def delete(id, idempotency_key: nil)
+        http_delete(path("/v1/webhooks", id!(id)), idempotency_key: idem(idempotency_key))
+      end
+
+      # Queue a webhook.test delivery. POST /v1/webhooks/{id}/test -> 202 { status: }.
+      def test(id, idempotency_key: nil)
+        @transport.request(:post, path("/v1/webhooks", id!(id), :test), idempotency_key: idem(idempotency_key))
+      end
+
+      # GET /v1/webhooks/{id}/deliveries -> Page<Delivery>.
+      def list_deliveries(id, params = nil, **kwargs)
+        http_page(path("/v1/webhooks", id!(id), :deliveries), Models.build(merge(params, kwargs), %i[limit cursor]))
+      end
+
+      # Replay a delivery.
+      # POST /v1/webhooks/{id}/deliveries/{delivery_id}/replay -> 202 { status: }.
+      #
+      # @param params [Hash] :generation (from the delivery), :reason (5..1000 chars)
+      def replay_delivery(id, delivery_id, params = nil, idempotency_key: nil, **kwargs)
+        body = Models.build(merge(params, kwargs), %i[generation reason], required: %i[generation reason])
+        @transport.request(:post, path("/v1/webhooks", id!(id), :deliveries, id!(delivery_id, "delivery_id"), :replay),
+                           body: body, idempotency_key: idem(idempotency_key))
+      end
+
+      # See {Opensms::Webhook.verify_signature}.
+      # @return [Boolean]
+      def verify_signature(payload, header, secret, tolerance_seconds: Webhook::DEFAULT_TOLERANCE, now: nil)
+        Webhook.verify_signature(payload, header, secret, tolerance_seconds: tolerance_seconds, now: now)
+      end
+
+      # See {Opensms::Webhook.construct_event}.
+      # @return [Opensms::WebhookEvent]
+      def construct_event(payload, header, secret, tolerance_seconds: Webhook::DEFAULT_TOLERANCE, now: nil)
+        Webhook.construct_event(payload, header, secret, tolerance_seconds: tolerance_seconds, now: now)
+      end
+    end
+  end
+end

data/lib/opensms/transport.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "securerandom"
+require "time"
+require "uri"
+
+require_relative "version"
+require_relative "error"
+
+module Opensms
+  # Default HTTP client: a thin Net::HTTP adapter. Any object that responds to
+  # +call(method, url, headers, body, timeout)+ and returns
+  # +[status, headers, body]+ (headers with lower-cased names, body a String or
+  # nil) can replace it through +Opensms::Client.new(http_client: ...)+.
+  class NetHttpClient
+    METHODS = {
+      get: Net::HTTP::Get,
+      post: Net::HTTP::Post,
+      put: Net::HTTP::Put,
+      patch: Net::HTTP::Patch,
+      delete: Net::HTTP::Delete
+    }.freeze
+
+    # @return [Array(Integer, Hash{String=>String}, String)]
+    def call(method, url, headers, body, timeout)
+      uri = URI.parse(url)
+      req = METHODS.fetch(method).new(uri)
+      headers.each { |k, v| req[k] = v }
+      req.body = body unless body.nil?
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = timeout
+      http.read_timeout = timeout
+      http.write_timeout = timeout if http.respond_to?(:write_timeout=)
+      res = http.request(req)
+
+      out = {}
+      res.each_header { |k, v| out[k.downcase] = v }
+      [res.code.to_i, out, res.body]
+    end
+  end
+
+  # HTTP transport: the single place that talks to the network. Owns bearer
+  # authentication, headers, JSON encode/decode, Idempotency-Key reuse,
+  # timeouts, retries with backoff, and turning non-2xx responses into
+  # {Opensms::Error}. Resources depend on this, never on Net::HTTP directly.
+  class Transport
+    DEFAULT_BASE_URL = "https://api.opensms.io"
+    USER_AGENT = "opensms-ruby/#{VERSION}"
+    RETRY_STATUSES = [429, 500, 502, 503, 504].freeze
+    MAX_RETRY_AFTER = 60
+    KEY_PATTERN = /\Ask_(test|live)_.{13,}\z/m.freeze
+
+    attr_reader :base_url, :environment
+
+    # @param api_key [String] "sk_test_..." or "sk_live_..."
+    # @param base_url [String]
+    # @param timeout [Numeric] seconds, per attempt
+    # @param max_retries [Integer] retries after the first attempt
+    # @param http_client [#call] see {NetHttpClient}
+    # @param sleeper [#call] receives the delay in seconds (tests inject a no-op)
+    # @param random [#call] returns a Float in [0, 1) for backoff jitter
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(api_key:, base_url: DEFAULT_BASE_URL, timeout: 30, max_retries: 2,
+                   http_client: nil, sleeper: nil, random: nil)
+      unless api_key.is_a?(String) && KEY_PATTERN.match?(api_key)
+        raise ArgumentError,
+              "Opensms: `api_key` must start with sk_test_ or sk_live_ followed by more than 12 characters."
+      end
+      raise ArgumentError, "Opensms: `max_retries` must be >= 0." unless max_retries.is_a?(Integer) && max_retries >= 0
+
+      @api_key = api_key
+      @environment = api_key.start_with?("sk_live_") ? "live" : "sandbox"
+      @base_url = (base_url || DEFAULT_BASE_URL).to_s.sub(%r{/+\z}, "")
+      @timeout = timeout
+      @max_retries = max_retries
+      @http_client = http_client || NetHttpClient.new
+      @sleeper = sleeper || ->(seconds) { sleep(seconds) }
+      @random = random || -> { Random.rand }
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    # Perform a request and return the decoded JSON body (symbol keys), or nil
+    # for 204 / empty bodies.
+    #
+    # @param method [Symbol] :get, :post, :put, :patch, :delete
+    # @param path [String] path beginning with "/" (segments already escaped)
+    # @param query [Hash, nil] nil values are dropped, arrays joined with ","
+    # @param body [Hash, Array, nil] JSON body
+    # @param raw_body [String, nil] raw body sent with +content_type+ instead of JSON
+    # @param content_type [String, nil]
+    # @param idempotency_key [String, nil] sent verbatim and reused on every retry
+    # @return [Hash, Array, nil]
+    # rubocop:disable Metrics/ParameterLists
+    def request(method, path, query: nil, body: nil, raw_body: nil, content_type: nil, idempotency_key: nil)
+      url = build_url(path, query)
+      headers = base_headers
+      payload = nil
+      if !raw_body.nil?
+        payload = raw_body
+        headers["Content-Type"] = content_type || "application/octet-stream"
+      elsif !body.nil?
+        payload = JSON.generate(body)
+        headers["Content-Type"] = "application/json"
+      end
+      headers["Idempotency-Key"] = idempotency_key unless idempotency_key.nil?
+      can_retry = method != :post || !idempotency_key.nil?
+
+      perform(method, url, headers, payload, can_retry)
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    private
+
+    def perform(method, url, headers, payload, can_retry)
+      attempt = 0
+      loop do
+        attempt += 1
+        retries_left = can_retry && attempt <= @max_retries
+        begin
+          status, res_headers, raw = @http_client.call(method, url, headers, payload, @timeout)
+        rescue StandardError => e
+          raise Error.new(status: 0, message: "OpenSMS request failed: #{e.class}: #{e.message}") unless retries_left
+
+          @sleeper.call(backoff(attempt))
+          next
+        end
+
+        res_headers = normalize_headers(res_headers)
+        return decode(raw) if status.between?(200, 299)
+
+        retry_after = parse_retry_after(res_headers["retry-after"])
+        error = Error.from_response(status, res_headers, raw, retry_after: retry_after)
+        raise error unless retries_left && RETRY_STATUSES.include?(status)
+        raise error if retry_after && retry_after > MAX_RETRY_AFTER
+
+        @sleeper.call(retry_after || backoff(attempt))
+      end
+    end
+
+    def base_headers
+      {
+        "Authorization" => "Bearer #{@api_key}",
+        "Accept" => "application/json",
+        "User-Agent" => USER_AGENT
+      }
+    end
+
+    def build_url(path, query)
+      url = "#{@base_url}#{path}"
+      return url if query.nil?
+
+      pairs = query.each_with_object([]) do |(k, v), acc|
+        next if v.nil?
+
+        acc << [k.to_s, v.is_a?(Array) ? v.join(",") : v.to_s]
+      end
+      return url if pairs.empty?
+
+      # Commas are legal in a query (RFC 3986 sub-delims); keep them literal so
+      # list values read as countries=KE,NG on the wire.
+      "#{url}?#{URI.encode_www_form(pairs).gsub('%2C', ',')}"
+    end
+
+    def normalize_headers(headers)
+      (headers || {}).each_with_object({}) do |(k, v), acc|
+        acc[k.to_s.downcase] = v.is_a?(Array) ? v.first : v
+      end
+    end
+
+    def decode(raw)
+      return nil if raw.nil? || raw.strip.empty?
+
+      JSON.parse(raw, symbolize_names: true)
+    rescue JSON::ParserError
+      raise Error.new(status: 0, message: "OpenSMS returned a response that is not valid JSON", body: raw)
+    end
+
+    # Full-jitter exponential backoff: random(0, min(8, 0.5 * 2^(n-1))).
+    def backoff(attempt)
+      cap = [8.0, 0.5 * (2**(attempt - 1))].min
+      @random.call * cap
+    end
+
+    # Retry-After is integer seconds or an HTTP date.
+    def parse_retry_after(value)
+      return nil if value.nil? || value.to_s.strip.empty?
+
+      text = value.to_s.strip
+      return text.to_i if text.match?(/\A\d+\z/)
+
+      [Time.httpdate(text) - Time.now, 0].max.ceil
+    rescue ArgumentError
+      nil
+    end
+  end
+end

data/lib/opensms/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Opensms
+  # The gem version. Bumped on release; tags use the `ruby-v*` prefix.
+  VERSION = "0.1.0"
+end

data/lib/opensms/webhook.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "json"
+require "openssl"
+
+require_relative "error"
+require_relative "models"
+
+module Opensms
+  # Webhook signature verification. Works without an API key, so a receiver
+  # only needs the endpoint secret.
+  #
+  # The API sends +X-OpenSMS-Signature: t=<unix seconds>,v1=<hex>+ where
+  # v1 = hex(HMAC-SHA256(secret, "<t>.<raw body>")). The secret is the full
+  # +whsec_...+ string returned once by +webhooks.create+, used verbatim.
+  #
+  # @example
+  #   event = Opensms::Webhook.construct_event(request.body.read,
+  #                                            request.get_header("HTTP_X_OPENSMS_SIGNATURE"),
+  #                                            ENV.fetch("OPENSMS_WEBHOOK_SECRET"))
+  module Webhook
+    HEADER = "X-OpenSMS-Signature"
+    DEFAULT_TOLERANCE = 300
+
+    module_function
+
+    # @param payload [String] the exact raw request body
+    # @param header [String, nil] the X-OpenSMS-Signature header value
+    # @param secret [String] the endpoint secret (whsec_...)
+    # @param tolerance_seconds [Integer] max clock skew, default 300
+    # @param now [Integer, Time, nil] current time, injectable for tests
+    # @return [Boolean]
+    def verify_signature(payload, header, secret, tolerance_seconds: DEFAULT_TOLERANCE, now: nil)
+      check(payload, header, secret, tolerance_seconds, now).nil?
+    end
+
+    # Verify the signature, then parse the body.
+    #
+    # @return [Opensms::WebhookEvent]
+    # @raise [Opensms::Error] status 0, code "invalid_signature" or "expired_signature"
+    def construct_event(payload, header, secret, tolerance_seconds: DEFAULT_TOLERANCE, now: nil)
+      failure = check(payload, header, secret, tolerance_seconds, now)
+      unless failure.nil?
+        message = failure == "expired_signature" ? "webhook signature timestamp is outside the tolerance" : "webhook signature is invalid"
+        raise Error.new(status: 0, code: failure, message: message)
+      end
+
+      begin
+        data = JSON.parse(payload.to_s, symbolize_names: true)
+      rescue JSON::ParserError
+        raise Error.new(status: 0, code: "invalid_payload", message: "webhook payload is not valid JSON", body: payload)
+      end
+      WebhookEvent.from(data.is_a?(Hash) ? data : {})
+    end
+
+    # Returns nil when valid, else "invalid_signature" or "expired_signature".
+    def check(payload, header, secret, tolerance, now)
+      return "invalid_signature" if secret.nil? || secret.strip.empty? || header.nil? || tolerance.negative?
+
+      parts = parse_header(header.to_s)
+      return "invalid_signature" if parts.nil?
+
+      t = parts["t"]
+      return "invalid_signature" unless t.match?(/\A[+-]?\d+\z/)
+
+      v1 = parts["v1"]
+      return "invalid_signature" unless v1.match?(/\A[0-9a-fA-F]{64}\z/)
+
+      now_s = now.nil? ? Time.now.to_i : now.to_i
+      return "expired_signature" if (now_s - t.to_i).abs > tolerance
+
+      expected = OpenSSL::HMAC.hexdigest("SHA256", secret.b, "#{t}.".b + payload.to_s.b)
+      secure_compare(expected, v1.downcase) ? nil : "invalid_signature"
+    end
+
+    # Mirror the server parser: exactly the keys t and v1, no duplicates, no
+    # empty keys or values.
+    def parse_header(header)
+      out = {}
+      header.split(",", -1).each do |part|
+        key, value = part.strip.split("=", 2)
+        return nil if key.nil? || key.empty? || value.nil? || value.empty?
+        return nil if out.key?(key)
+
+        out[key] = value
+      end
+      out.keys.sort == %w[t v1] ? out : nil
+    end
+
+    def secure_compare(a, b)
+      return false unless a.bytesize == b.bytesize
+
+      OpenSSL.fixed_length_secure_compare(a, b)
+    end
+  end
+end

data/lib/opensms.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "opensms/version"
+require_relative "opensms/error"
+require_relative "opensms/models"
+require_relative "opensms/transport"
+require_relative "opensms/webhook"
+require_relative "opensms/client"
+
+# Ruby SDK for the OpenSMS API (https://opensms.io).
+#
+# @example
+#   require "opensms"
+#   client = Opensms::Client.new(api_key: ENV.fetch("OPENSMS_API_KEY"))
+#   client.messages.send(to: "+254700000012", text: "Hello from Ruby")
+module Opensms
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: opensms
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- OpenSMS
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-09-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Send SMS and OTPs, run batches, look up numbers, and manage contacts,
+  templates, webhooks, numbers, sender IDs, suppressions and wallet through the OpenSMS
+  API. Zero runtime dependencies.
+email:
+- engineering@opensms.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/opensms.rb
+- lib/opensms/client.rb
+- lib/opensms/error.rb
+- lib/opensms/models.rb
+- lib/opensms/pagination.rb
+- lib/opensms/resources/analytics.rb
+- lib/opensms/resources/base.rb
+- lib/opensms/resources/batches.rb
+- lib/opensms/resources/compliance.rb
+- lib/opensms/resources/contact_groups.rb
+- lib/opensms/resources/contacts.rb
+- lib/opensms/resources/countries.rb
+- lib/opensms/resources/inbound.rb
+- lib/opensms/resources/lookups.rb
+- lib/opensms/resources/messages.rb
+- lib/opensms/resources/numbers.rb
+- lib/opensms/resources/otp.rb
+- lib/opensms/resources/pricing.rb
+- lib/opensms/resources/sandbox.rb
+- lib/opensms/resources/sender_ids.rb
+- lib/opensms/resources/suppressions.rb
+- lib/opensms/resources/templates.rb
+- lib/opensms/resources/wallet.rb
+- lib/opensms/resources/webhooks.rb
+- lib/opensms/transport.rb
+- lib/opensms/version.rb
+- lib/opensms/webhook.rb
+homepage: https://opensms.io
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://opensms.io
+  source_code_uri: https://github.com/opensms-io/opensms-sdks
+  documentation_uri: https://docs.opensms.io
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Ruby SDK for the OpenSMS API.
+test_files: []