smsru_ruby 1.0.0

data/lib/sms_ru/stoplist.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class SmsRu
+  # Manages the account stoplist (numbers that never receive messages and are
+  # never charged). Reached via SmsRu#stoplist, e.g. `client.stoplist.add(...)`.
+  class Stoplist
+    # @api private
+    # @param request [Method] the client's bound `request` method
+    def initialize(request)
+      @request = request
+    end
+
+    # Adds a number to the stoplist. `note` is visible only to you.
+    #
+    # @param phone [String, Integer] the number to stoplist
+    # @param note [String, nil] an optional private note
+    # @return [Boolean] true on success
+    # @raise [SmsRu::ResponseError] if SMS.ru rejects the request
+    def add(phone, note: nil)
+      @request.call("/stoplist/add", stoplist_phone: phone.to_s, stoplist_text: note.to_s)
+      true
+    end
+
+    # Removes a number from the stoplist.
+    #
+    # @param phone [String, Integer] the number to remove
+    # @return [Boolean] true on success
+    # @raise [SmsRu::ResponseError] if SMS.ru rejects the request
+    def remove(phone)
+      @request.call("/stoplist/del", stoplist_phone: phone.to_s)
+      true
+    end
+
+    # Returns every stoplisted number as an Array of SmsRu::StoplistEntry.
+    #
+    # @return [Array<SmsRu::StoplistEntry>]
+    # @raise [SmsRu::ResponseError] if SMS.ru rejects the request
+    def list
+      data = @request.call("/stoplist/get")
+      Coerce.records(data["stoplist"]).map { |phone, note| StoplistEntry.new(phone: String(phone), note: String(note)) }
+    end
+  end
+end

data/lib/sms_ru/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class SmsRu
+  # The gem version.
+  VERSION = "1.0.0"
+end

data/lib/sms_ru/webhook.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+class SmsRu
+  # Parses the inbound webhook payload SMS.ru POSTs to your callback URL and
+  # verifies its signature. SMS.ru sends the records as POST fields
+  # `data[0]..data[N]` (so `params["data"]` is a Hash in Rack/Rails, an Array
+  # in PHP) plus a `hash` field; acknowledge the webhook by replying with "100".
+  #
+  # {parse} returns one typed event per record — a {SmsRu::Events::SmsStatus},
+  # {SmsRu::Events::CallcheckStatus}, {SmsRu::Events::Test}, or
+  # {SmsRu::Events::Unknown} — best handled with a case match:
+  #
+  #   return head(:forbidden) unless SmsRu::Webhook.valid?(params["data"], params["hash"], api_id)
+  #   SmsRu::Webhook.parse(params["data"]).each do |event|
+  #     case event
+  #     when SmsRu::Events::SmsStatus       then update_delivery(event.id, event.status_code)
+  #     when SmsRu::Events::CallcheckStatus then confirm(event.id) if event.confirmed?
+  #     end
+  #   end
+  module Webhook
+    # @param data [Hash, Array<String>, String, nil] the POST "data" parameter
+    # @return [Array<SmsRu::Events::SmsStatus, SmsRu::Events::CallcheckStatus,
+    #   SmsRu::Events::Test, SmsRu::Events::Unknown>] one event per record
+    def self.parse(data)
+      entries(data).map do |entry|
+        lines = entry.to_s.split("\n")
+        case lines[0]
+        when "sms_status"       then Events::SmsStatus.new(**status_fields(lines))
+        when "callcheck_status" then Events::CallcheckStatus.new(**status_fields(lines))
+        when "test"             then Events::Test.new(created_at: time(lines[1]), raw: lines)
+        else                         Events::Unknown.new(type: lines[0].to_s, raw: lines)
+        end
+      end
+    end
+
+    # Verifies the payload genuinely came from SMS.ru (constant-time compare of
+    # SMS.ru's `hash` against `sha256(api_id + concatenated data entries)`).
+    #
+    # @param data [Hash, Array<String>, String, nil] the POST "data" parameter
+    # @param hash [String, nil] the POST "hash" parameter
+    # @param api_id [String] your SMS.ru API id
+    # @return [Boolean] true when the signature matches
+    def self.valid?(data, hash, api_id)
+      return false unless hash.is_a?(String)
+
+      expected = OpenSSL::Digest::SHA256.hexdigest("#{api_id}#{entries(data).join}")
+      expected.bytesize == hash.bytesize && OpenSSL.fixed_length_secure_compare(expected, hash)
+    end
+
+    # Common fields of the "type / id / status / timestamp" status records.
+    # @api private
+    def self.status_fields(lines)
+      { id: lines[1].to_s, status_code: Coerce.integer?(lines[2]), created_at: time(lines[3]), raw: lines }
+    end
+
+    # Normalizes the `data` param to an ordered Array of record strings. SMS.ru
+    # numbers the fields data[0..N]; Rack delivers them as a Hash, so sort by
+    # the numeric key to preserve SMS.ru's order (the signature depends on it).
+    #
+    # @api private
+    # @param data [Hash, Array<String>, String, nil] the POST "data" parameter
+    # @return [Array<String>] the records in the order SMS.ru sent them
+    def self.entries(data)
+      data.is_a?(Hash) ? data.sort_by { |k, _| Coerce.integer(k) }.map(&:last) : Array(data)
+    end
+
+    # Converts a unix-timestamp line into a Time, or nil when absent.
+    # @api private
+    def self.time(str)
+      unix = Coerce.integer?(str)
+      unix && Time.at(unix)
+    end
+  end
+end

data/lib/smsru_ruby.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "openssl"
+
+require_relative "sms_ru/version"
+require_relative "sms_ru/errors"
+require_relative "sms_ru/statuses"
+require_relative "sms_ru/coerce"
+require_relative "sms_ru/data"
+require_relative "sms_ru/events"
+require_relative "sms_ru/webhook"
+require_relative "sms_ru/my"
+require_relative "sms_ru/auth"
+require_relative "sms_ru/stoplist"
+require_relative "sms_ru/callbacks"
+require_relative "sms_ru/call_check"
+require_relative "sms_ru/client"

data/sig/manifest.yaml

@@ -0,0 +1,9 @@
+# Standard-library signatures these RBS files reference. Consumers' RBS/Steep
+# load these automatically when they depend on smsru_ruby. (The gem has no
+# runtime gem dependencies, so none are auto-derived from the gemspec.)
+dependencies:
+  - name: logger      # Logger? in SmsRu#initialize
+  - name: openssl     # Webhook signature verification
+  - name: json        # client request parsing
+  - name: net-http    # client transport
+  - name: uri         # client transport

data/sig/sms_ru/auth.rbs

@@ -0,0 +1,9 @@
+class SmsRu
+  # Authentication checks against the account.
+  class Auth
+    @request: _Request
+
+    def initialize: (_Request request) -> void
+    def ok?: () -> bool
+  end
+end

data/sig/sms_ru/call_check.rbs

@@ -0,0 +1,10 @@
+class SmsRu
+  # Authorizes a user by an incoming call from their own number.
+  class CallCheck
+    @request: _Request
+
+    def initialize: (_Request request) -> void
+    def add: (String | Integer phone) -> CallCheckResult
+    def status: (String | Integer check_id) -> CallCheckStatus
+  end
+end

data/sig/sms_ru/callbacks.rbs

@@ -0,0 +1,15 @@
+class SmsRu
+  # Manages callback (webhook) URLs that SMS.ru notifies with delivery statuses.
+  class Callbacks
+    @request: _Request
+
+    def initialize: (_Request request) -> void
+    def add: (String url) -> Array[String]
+    def remove: (String url) -> Array[String]
+    def list: () -> Array[String]
+
+    private
+
+    def urls: (Hash[String, untyped] data) -> Array[String]
+  end
+end

data/sig/sms_ru/client.rbs

@@ -0,0 +1,53 @@
+# Ruby client for the SMS.ru HTTP API (https://sms.ru/api).
+class SmsRu
+  # The client's bound `request` method as handed to each sub-resource. A
+  # `Method` conforms structurally, so `method(:request)` is accepted here while
+  # callers still see a typed `Hash[String, untyped]` return instead of untyped.
+  interface _Request
+    def call: (String path, **untyped params) -> Hash[String, untyped]
+  end
+
+  BASE_URL: String
+  # Singletons (not bare Class) so `rescue *RETRIABLE => e` types e as StandardError.
+  RETRIABLE: Array[singleton(StandardError)]
+
+  @api_id: String
+  @timeout: Integer
+  @test: bool
+  @retries: Integer
+  @from: String?
+  @logger: Logger?
+  @my: My?
+  @auth: Auth?
+  @stoplist: Stoplist?
+  @callbacks: Callbacks?
+  @callcheck: CallCheck?
+
+  def initialize: (String api_id, ?timeout: Integer, ?test: bool, ?retries: Integer, ?from: String?, ?logger: Logger?) -> void
+
+  def deliver: (String | Array[String] | Hash[String, String] to, ?String? text,
+                ?from: String?, ?time: Integer?, ?ttl: Integer?, ?daytime: bool,
+                ?translit: bool, ?test: bool?, ?ip: String?, ?partner_id: Integer?) -> SendResult
+
+  def cost: (String | Array[String] to, ?String? text, ?translit: bool) -> Cost
+
+  def status: (String | Array[String] sms_id) -> (Status | Array[Status])
+
+  def call: (String | Integer phone, ?ip: String, ?partner_id: Integer?) -> Call
+
+  def my: () -> My
+  def auth: () -> Auth
+  def stoplist: () -> Stoplist
+  def callbacks: () -> Callbacks
+  def callcheck: () -> CallCheck
+
+  private
+
+  def add_recipients: (Hash[untyped, untyped] params, String | Array[String] | Hash[String, String] to, String? text) -> void
+  def request: (String path, **untyped params) -> Hash[String, untyped]
+  def perform: (URI::HTTP uri, String body) -> Hash[String, untyped]
+  def http: (URI::HTTP uri) -> Net::HTTP
+  def parse: (String? raw) -> Hash[String, untyped]
+  def error_for: (Hash[String, untyped] data) -> ResponseError
+  def error_class: (Integer code) -> singleton(ResponseError)
+end

data/sig/sms_ru/coerce.rbs

@@ -0,0 +1,15 @@
+class SmsRu
+  # Normalizes loosely-typed SMS.ru JSON values into the result objects' types.
+  # `self?.` mirrors `module_function`: each helper is both a private instance
+  # method and a public singleton method. The `?` variant is nullable; the plain
+  # variant falls back to a (overridable) default, so it never returns nil.
+  module Coerce
+    def self?.string?: (untyped value) -> String?
+    def self?.string: (untyped value, ?String default) -> String
+    def self?.integer?: (untyped value) -> Integer?
+    def self?.integer: (untyped value, ?Integer default) -> Integer
+    def self?.float?: (untyped value) -> Float?
+    def self?.float: (untyped value, ?Float default) -> Float
+    def self?.records: (untyped value) -> Hash[untyped, untyped]
+  end
+end

data/sig/sms_ru/data.rbs

@@ -0,0 +1,141 @@
+class SmsRu
+  # Self-type element for MessageCollection: each entry responds to #ok?.
+  interface _OkItem
+    def ok?: () -> bool
+  end
+
+  # Self-type host for MessageCollection: exposes a `messages` array of _OkItem.
+  interface _MessageHost[E]
+    def messages: () -> Array[E]
+  end
+
+  # Collection helpers shared by results wrapping a `messages` array.
+  module MessageCollection[E < _OkItem] : _MessageHost[E]
+    def ok?: () -> bool
+    def ok: () -> Array[E]
+    def failed: () -> Array[E]
+  end
+
+  # A single message inside a send response.
+  class Sms
+    attr_reader phone: String
+    attr_reader sms_id: String?
+    attr_reader error_code: Integer?
+    attr_reader error_text: String?
+
+    def initialize: (phone: String, sms_id: String?, error_code: Integer?, error_text: String?) -> void
+    def self.build: (String phone, Hash[String, untyped] hash) -> Sms
+    def ok?: () -> bool
+  end
+
+  # Result of SmsRu#deliver.
+  class SendResult
+    include MessageCollection[Sms]
+
+    attr_reader balance: Float
+    attr_reader messages: Array[Sms]
+
+    def initialize: (balance: Float, messages: Array[Sms]) -> void
+    def self.build: (Hash[String, untyped] hash) -> SendResult
+  end
+
+  # Delivery status of one message.
+  class Status
+    include DeliveryStatus
+
+    attr_reader sms_id: String
+    attr_reader status_code: Integer
+    attr_reader status_text: String
+    attr_reader cost: Float?
+
+    def initialize: (sms_id: String, status_code: Integer, status_text: String, cost: Float?) -> void
+    def self.build: (String sms_id, Hash[String, untyped] hash) -> Status
+    def self.build_all: (Hash[String, untyped] hash) -> Array[Status]
+    def found?: () -> bool
+  end
+
+  # Per-recipient cost (one entry of a /sms/cost response).
+  class CostItem
+    attr_reader phone: String
+    attr_reader cost: Float?
+    attr_reader sms_count: Integer?
+    attr_reader error_code: Integer?
+    attr_reader error_text: String?
+
+    def initialize: (phone: String, cost: Float?, sms_count: Integer?, error_code: Integer?, error_text: String?) -> void
+    def self.build: (String phone, Hash[String, untyped] hash) -> CostItem
+    def ok?: () -> bool
+  end
+
+  # Result of SmsRu#cost.
+  class Cost
+    include MessageCollection[CostItem]
+
+    attr_reader total_cost: Float
+    attr_reader total_sms: Integer
+    attr_reader messages: Array[CostItem]
+
+    def initialize: (total_cost: Float, total_sms: Integer, messages: Array[CostItem]) -> void
+    def self.build: (Hash[String, untyped] hash) -> Cost
+  end
+
+  # Result of SmsRu#call (flash call).
+  class Call
+    attr_reader code: String
+    attr_reader call_id: String
+    attr_reader cost: Float
+    attr_reader balance: Float
+
+    def initialize: (code: String, call_id: String, cost: Float, balance: Float) -> void
+    def self.build: (Hash[String, untyped] hash) -> Call
+  end
+
+  # Result of SmsRu::My#limit (daily sending limit).
+  class Limit
+    attr_reader total_limit: Integer
+    attr_reader used_today: Integer
+
+    def initialize: (total_limit: Integer, used_today: Integer) -> void
+    def self.build: (Hash[String, untyped] hash) -> Limit
+    def available_today: () -> Integer
+  end
+
+  # Result of SmsRu::My#free_limit (free daily messages).
+  class FreeLimit
+    attr_reader total_free: Integer
+    attr_reader used_today: Integer
+
+    def initialize: (total_free: Integer, used_today: Integer) -> void
+    def self.build: (Hash[String, untyped] hash) -> FreeLimit
+    def available_today: () -> Integer
+  end
+
+  # Result of SmsRu::CallCheck#add.
+  class CallCheckResult
+    attr_reader check_id: String
+    attr_reader call_phone: String
+    attr_reader call_phone_pretty: String
+    attr_reader call_phone_html: String
+
+    def initialize: (check_id: String, call_phone: String, call_phone_pretty: String, call_phone_html: String) -> void
+    def self.build: (Hash[String, untyped] hash) -> CallCheckResult
+  end
+
+  # Result of SmsRu::CallCheck#status.
+  class CallCheckStatus
+    attr_reader status_code: Integer
+    attr_reader status_text: String
+
+    def initialize: (status_code: Integer, status_text: String) -> void
+    def self.build: (Hash[String, untyped] hash) -> CallCheckStatus
+    def confirmed?: () -> bool
+  end
+
+  # One stoplist entry returned by SmsRu::Stoplist#list.
+  class StoplistEntry
+    attr_reader phone: String
+    attr_reader note: String
+
+    def initialize: (phone: String, note: String) -> void
+  end
+end

data/sig/sms_ru/errors.rbs

@@ -0,0 +1,25 @@
+class SmsRu
+  # Base class for every error raised by the gem.
+  class Error < StandardError
+  end
+
+  # Raised when SMS.ru cannot be reached or returns an unparseable body.
+  class ConnectionError < Error
+  end
+
+  # Raised when SMS.ru replies with a non-OK status.
+  class ResponseError < Error
+    attr_reader code: Integer
+    attr_reader text: String
+
+    def initialize: (code: Integer, text: String) -> void
+  end
+
+  # Invalid api_id / token / unconfirmed account (codes 200, 300, 301, 302).
+  class AuthError < ResponseError
+  end
+
+  # Not enough money on the account (code 201).
+  class InsufficientFundsError < ResponseError
+  end
+end

data/sig/sms_ru/events.rbs

@@ -0,0 +1,49 @@
+class SmsRu
+  # Typed events decoded from an inbound SMS.ru webhook payload.
+  module Events
+    # A delivery-status notification (record type "sms_status"). Its `status_code`
+    # is nullable (a malformed line yields nil); DeliveryStatus's predicates
+    # nil-guard, so the module is included directly here as it is at runtime.
+    class SmsStatus
+      include DeliveryStatus
+
+      attr_reader id: String
+      attr_reader status_code: Integer?
+      attr_reader created_at: Time?
+      attr_reader raw: Array[String]
+
+      def initialize: (id: String, status_code: Integer?, created_at: Time?, raw: Array[String]) -> void
+      def type: () -> String
+    end
+
+    # A call-authorization notification (record type "callcheck_status").
+    class CallcheckStatus
+      attr_reader id: String
+      attr_reader status_code: Integer?
+      attr_reader created_at: Time?
+      attr_reader raw: Array[String]
+
+      def initialize: (id: String, status_code: Integer?, created_at: Time?, raw: Array[String]) -> void
+      def type: () -> String
+      def confirmed?: () -> bool
+      def expired?: () -> bool
+    end
+
+    # SMS.ru's periodic heartbeat record (record type "test").
+    class Test
+      attr_reader created_at: Time?
+      attr_reader raw: Array[String]
+
+      def initialize: (created_at: Time?, raw: Array[String]) -> void
+      def type: () -> String
+    end
+
+    # Any record type this gem does not model explicitly.
+    class Unknown
+      attr_reader type: String
+      attr_reader raw: Array[String]
+
+      def initialize: (type: String, raw: Array[String]) -> void
+    end
+  end
+end

data/sig/sms_ru/my.rbs

@@ -0,0 +1,12 @@
+class SmsRu
+  # Account information: balance, daily limit, free quota, approved sender names.
+  class My
+    @request: _Request
+
+    def initialize: (_Request request) -> void
+    def balance: () -> Float
+    def limit: () -> Limit
+    def free_limit: () -> FreeLimit
+    def senders: () -> Array[String]
+  end
+end

data/sig/sms_ru/statuses.rbs

@@ -0,0 +1,35 @@
+class SmsRu
+  # Delivery status codes returned by /sms/status and carried in `sms_status` webhooks.
+  module Statuses
+    NOT_FOUND: Integer
+    QUEUED: Integer
+    SENT_TO_OPERATOR: Integer
+    IN_TRANSIT: Integer
+    DELIVERED: Integer
+    EXPIRED: Integer
+    DELETED: Integer
+    PHONE_FAILURE: Integer
+    UNKNOWN_FAILURE: Integer
+    REJECTED: Integer
+    READ: Integer
+    NO_ROUTE: Integer
+
+    PENDING: Array[Integer]
+    FAILED: Array[Integer]
+  end
+
+  # Self-type for DeliveryStatus: the including object must expose `status_code`.
+  # Nullable so both SmsRu::Status (always present) and SmsRu::Events::SmsStatus
+  # (nil for a malformed webhook line) can include the module; the predicates
+  # nil-guard before the Array#include? lookups.
+  interface _HasStatusCode
+    def status_code: () -> Integer?
+  end
+
+  # Delivery-state predicates shared by SmsRu::Status and SmsRu::Events::SmsStatus.
+  module DeliveryStatus : _HasStatusCode
+    def delivered?: () -> bool
+    def pending?: () -> bool
+    def failed?: () -> bool
+  end
+end

data/sig/sms_ru/stoplist.rbs

@@ -0,0 +1,11 @@
+class SmsRu
+  # Manages the account stoplist.
+  class Stoplist
+    @request: _Request
+
+    def initialize: (_Request request) -> void
+    def add: (String | Integer phone, ?note: String?) -> bool
+    def remove: (String | Integer phone) -> bool
+    def list: () -> Array[StoplistEntry]
+  end
+end

data/sig/sms_ru/version.rbs

@@ -0,0 +1,3 @@
+class SmsRu
+  VERSION: String
+end

data/sig/sms_ru/webhook.rbs

@@ -0,0 +1,17 @@
+class SmsRu
+  # Parses the inbound webhook payload SMS.ru POSTs to your callback URL and
+  # verifies its signature.
+  module Webhook
+    type payload = Hash[untyped, untyped] | Array[String] | String | nil
+    type event = Events::SmsStatus | Events::CallcheckStatus | Events::Test | Events::Unknown
+
+    def self.parse: (payload data) -> Array[event]
+    def self.valid?: (payload data, String? hash, String api_id) -> bool
+
+    # @api private helpers. status_fields returns a record so Steep can expand it
+    # into the SmsStatus/CallcheckStatus keyword constructors via `**`.
+    def self.status_fields: (Array[String] lines) -> { id: String, status_code: Integer?, created_at: Time?, raw: Array[String] }
+    def self.entries: (payload data) -> Array[String]
+    def self.time: (String? str) -> Time?
+  end
+end

data/smsru_ruby.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "lib/sms_ru/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "smsru_ruby"
+  spec.version = SmsRu::VERSION
+  spec.authors = ["Leonid Svyatov"]
+  spec.email = ["leonid@svyatov.com"]
+
+  spec.summary = "Modern, dependency-free Ruby client for the SMS.ru API."
+  spec.description = "A modern, dependency-free Ruby client for the SMS.ru HTTP API. Send single or bulk SMS, " \
+                     "schedule delivery, check cost and delivery status, verify users by phone call, inspect " \
+                     "balance/limits/senders, manage the stoplist, and register delivery callbacks."
+  spec.homepage = "https://github.com/svyatov/smsru_ruby"
+  spec.license = "MIT"
+
+  spec.required_ruby_version = ">= 3.2.0"
+
+  spec.require_paths = ["lib"]
+  spec.files = Dir["lib/**/*.rb"] + Dir["sig/**/*"] +
+               %w[.yardopts CHANGELOG.md LICENSE.txt README.md smsru_ruby.gemspec]
+
+  spec.metadata["rubygems_mfa_required"] = "true"
+  spec.metadata["documentation_uri"] = "https://rubydoc.info/gems/smsru_ruby"
+  spec.metadata["source_code_uri"] = "https://github.com/svyatov/smsru_ruby"
+  spec.metadata["changelog_uri"] = "https://github.com/svyatov/smsru_ruby/blob/main/CHANGELOG.md"
+  spec.metadata["bug_tracker_uri"] = "https://github.com/svyatov/smsru_ruby/issues"
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: smsru_ruby
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Leonid Svyatov
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A modern, dependency-free Ruby client for the SMS.ru HTTP API. Send single
+  or bulk SMS, schedule delivery, check cost and delivery status, verify users by
+  phone call, inspect balance/limits/senders, manage the stoplist, and register delivery
+  callbacks.
+email:
+- leonid@svyatov.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/sms_ru/auth.rb
+- lib/sms_ru/call_check.rb
+- lib/sms_ru/callbacks.rb
+- lib/sms_ru/client.rb
+- lib/sms_ru/coerce.rb
+- lib/sms_ru/data.rb
+- lib/sms_ru/errors.rb
+- lib/sms_ru/events.rb
+- lib/sms_ru/my.rb
+- lib/sms_ru/statuses.rb
+- lib/sms_ru/stoplist.rb
+- lib/sms_ru/version.rb
+- lib/sms_ru/webhook.rb
+- lib/smsru_ruby.rb
+- sig/manifest.yaml
+- sig/sms_ru/auth.rbs
+- sig/sms_ru/call_check.rbs
+- sig/sms_ru/callbacks.rbs
+- sig/sms_ru/client.rbs
+- sig/sms_ru/coerce.rbs
+- sig/sms_ru/data.rbs
+- sig/sms_ru/errors.rbs
+- sig/sms_ru/events.rbs
+- sig/sms_ru/my.rbs
+- sig/sms_ru/statuses.rbs
+- sig/sms_ru/stoplist.rbs
+- sig/sms_ru/version.rbs
+- sig/sms_ru/webhook.rbs
+- smsru_ruby.gemspec
+homepage: https://github.com/svyatov/smsru_ruby
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  documentation_uri: https://rubydoc.info/gems/smsru_ruby
+  source_code_uri: https://github.com/svyatov/smsru_ruby
+  changelog_uri: https://github.com/svyatov/smsru_ruby/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/svyatov/smsru_ruby/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.12
+specification_version: 4
+summary: Modern, dependency-free Ruby client for the SMS.ru API.
+test_files: []