kirimi 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0bc013f5f011e16f83060dc902e32b6cf6c45312c2d6c443cb882503babed732
+  data.tar.gz: '082c9dcd26bee5df651c865dc77c93222c49f8fa70e68d4e5970ef9013efad17'
+SHA512:
+  metadata.gz: 487b38bee90b1463c0550efdb36a7646e0bdfd50ec2f0e598407bf4aacf3b0a3a770f0c0fead719b0fb98ad68debfa54e8b26574a538c5b76b4ff1cefa94d0a4
+  data.tar.gz: cc5f8545838710df3641cf0207aa2dc9d168c906f76a2edc1d288942f4ce05677ed9ffa50e7c2c45c5b6128dcafec5950cf0198bc821cf989fcd66cf5d7fafe2

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## [0.1.0] - 2026-04-14
+
+### Added
+- Initial release
+- 16 Kirimi API endpoints supported
+- Zero runtime dependencies (uses Ruby stdlib `net/http`)

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kirimi
+
+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 @@
+# Kirimi Ruby SDK
+
+[![Gem Version](https://badge.fury.io/rb/kirimi.svg)](https://badge.fury.io/rb/kirimi)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+Official Ruby SDK for the [Kirimi WhatsApp API](https://kirimi.id). Zero runtime dependencies — uses only Ruby's built-in `net/http`.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'kirimi'
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+Or install directly:
+
+```bash
+gem install kirimi
+```
+
+## Quick Start
+
+```ruby
+require 'kirimi'
+
+client = Kirimi::Client.new(
+  user_code: 'YOUR_USER_CODE',
+  secret:    'YOUR_SECRET'
+)
+
+resp = client.send_message(
+  device_id: 'YOUR_DEVICE_ID',
+  phone:     '628111222333',
+  message:   'Hello from Kirimi!'
+)
+
+puts resp.success?  # => true
+puts resp.message   # => "Message sent"
+puts resp.data      # => { ... }
+```
+
+## Constructor
+
+```ruby
+Kirimi::Client.new(
+  user_code: 'YOUR_USER_CODE',   # required
+  secret:    'YOUR_SECRET',      # required
+  base_url:  'https://api.kirimi.id',  # optional, default
+  timeout:   30                  # optional, seconds
+)
+```
+
+## All Methods
+
+### WhatsApp Unofficial
+
+```ruby
+# Send text/media message
+client.send_message(device_id:, phone:, message:, media_url: nil)
+
+# Send file via multipart (accepts File, StringIO, or file path string)
+client.send_message_file(device_id:, phone:, file:, file_name:, message: nil)
+
+# Send message without typing indicator
+client.send_message_fast(device_id:, phone:, message:, media_url: nil)
+```
+
+### WABA (WhatsApp Business API)
+
+```ruby
+client.send_waba_message(device_id:, phone:, message:)
+```
+
+### Devices
+
+```ruby
+client.list_devices
+client.device_status(device_id:)
+client.device_status_enhanced(device_id:)
+```
+
+### User
+
+```ruby
+client.user_info
+```
+
+### Contacts
+
+```ruby
+client.save_contact(phone:, name: nil, email: nil)
+```
+
+### OTP (V1)
+
+```ruby
+# Generate & send OTP
+client.generate_otp(
+  device_id:,
+  phone:,
+  otp_length:        6,        # optional
+  otp_type:          'numeric', # optional: numeric, alphabetic, alphanumeric
+  custom_otp_message: nil      # optional
+)
+
+# Validate OTP
+client.validate_otp(device_id:, phone:, otp:)
+```
+
+### OTP (V2)
+
+```ruby
+# Send OTP via WABA template or device
+client.send_otp_v2(
+  phone:,
+  device_id:,
+  method:        'device', # optional: device, waba
+  app_name:      'MyApp',  # optional
+  template_code: nil,      # optional, for waba method
+  custom_message: nil      # optional, for device method
+)
+
+# Verify OTP
+client.verify_otp_v2(phone:, otp_code:)
+```
+
+### Broadcast
+
+```ruby
+# phones accepts String or Array (Array auto-joined with comma)
+client.broadcast_message(
+  device_id:,
+  phones:   ['628111', '628222', '628333'],
+  message:  'Promo!',
+  delay:    2  # optional, seconds between messages
+)
+```
+
+### Deposits
+
+```ruby
+client.list_deposits(status: nil)  # status: nil, 'paid', 'unpaid', 'expired'
+client.list_packages
+```
+
+## Response Object
+
+All methods return a `Kirimi::Response` instance:
+
+```ruby
+resp = client.send_message(device_id: 'DEV', phone: '628xxx', message: 'hi')
+
+resp.success?  # => true / false (boolean method)
+resp.success   # => true / false (raw value)
+resp.data      # => Hash or nil
+resp.message   # => String
+resp.raw       # => full parsed Hash
+```
+
+## Error Handling
+
+```ruby
+begin
+  resp = client.send_message(device_id: 'DEV', phone: '628xxx', message: 'hi')
+rescue Kirimi::ApiError => e
+  puts e.status_code    # => 401
+  puts e.message        # => "Unauthorized"
+  puts e.response_data  # => parsed response body
+rescue Kirimi::NetworkError => e
+  puts "Network problem: #{e.message}"
+rescue Kirimi::Error => e
+  puts "SDK error: #{e.message}"
+end
+```
+
+## Rails Integration
+
+### Application configuration
+
+```ruby
+# config/initializers/kirimi.rb
+KIRIMI_CLIENT = Kirimi::Client.new(
+  user_code: ENV.fetch('KIRIMI_USER_CODE'),
+  secret:    ENV.fetch('KIRIMI_SECRET')
+)
+```
+
+### Controller example
+
+```ruby
+class NotificationsController < ApplicationController
+  def send_otp
+    resp = KIRIMI_CLIENT.generate_otp(
+      device_id: params[:device_id],
+      phone:     params[:phone],
+      otp_length: 6,
+      otp_type:   'numeric'
+    )
+
+    if resp.success?
+      render json: { sent: true }
+    else
+      render json: { sent: false, error: resp.message }, status: :unprocessable_entity
+    end
+  rescue Kirimi::ApiError => e
+    render json: { error: e.message }, status: e.status_code
+  end
+end
+```
+
+### Background Job example
+
+```ruby
+class SendWhatsAppJob < ApplicationJob
+  queue_as :default
+
+  def perform(device_id, phone, message)
+    KIRIMI_CLIENT.send_message(device_id: device_id, phone: phone, message: message)
+  rescue Kirimi::ApiError, Kirimi::NetworkError => e
+    Rails.logger.error "[Kirimi] #{e.class}: #{e.message}"
+    raise  # re-raise to trigger job retry
+  end
+end
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

data/kirimi.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'lib/kirimi/version'
+
+Gem::Specification.new do |spec|
+  spec.name    = 'kirimi'
+  spec.version = Kirimi::VERSION
+  spec.authors = ['Kirimi']
+  spec.email   = ['support@kirimi.id']
+
+  spec.summary     = 'Official Ruby SDK for Kirimi WhatsApp API'
+  spec.description = 'Send WhatsApp messages, OTP, broadcasts, and more via the Kirimi API.'
+  spec.homepage    = 'https://github.com/kiriminow/kirimi-ruby'
+  spec.license     = 'MIT'
+
+  spec.required_ruby_version = '>= 2.6.0'
+
+  spec.metadata['homepage_uri']    = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri']   = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  spec.files         = Dir.glob(%w[lib/**/* LICENSE README.md CHANGELOG.md kirimi.gemspec])
+  spec.test_files    = Dir.glob('test/**/*_test.rb')
+  spec.require_paths = ['lib']
+
+  # No runtime dependencies — uses only Ruby stdlib (net/http, json, securerandom)
+
+  spec.add_development_dependency 'rake', '~> 13.0'
+end

data/lib/kirimi/client.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module Kirimi
+  class Client
+    DEFAULT_BASE_URL = 'https://api.kirimi.id'
+    DEFAULT_TIMEOUT  = 30
+
+    def initialize(user_code:, secret:, base_url: DEFAULT_BASE_URL, timeout: DEFAULT_TIMEOUT)
+      @user_code = user_code
+      @secret    = secret
+      @base_url  = base_url.chomp('/')
+      @timeout   = timeout
+    end
+
+    # --- WhatsApp Unofficial ---
+
+    def send_message(device_id:, phone:, message:, media_url: nil)
+      body = { device_id: device_id, phone: phone, message: message }
+      body[:media_url] = media_url if media_url
+      post('/v1/send-message', body)
+    end
+
+    def send_message_file(device_id:, phone:, file:, file_name:, message: nil)
+      file_io = file.is_a?(String) ? File.open(file, 'rb') : file
+      fields = {
+        'user_code' => @user_code,
+        'secret'    => @secret,
+        'device_id' => device_id,
+        'phone'     => phone,
+        'fileName'  => file_name
+      }
+      fields['message'] = message if message
+      post_multipart('/v1/send-message-file', fields, file_io, file_name)
+    ensure
+      file_io&.close if file.is_a?(String)
+    end
+
+    def send_message_fast(device_id:, phone:, message:, media_url: nil)
+      body = { device_id: device_id, phone: phone, message: message }
+      body[:media_url] = media_url if media_url
+      post('/v1/send-message-fast', body)
+    end
+
+    # --- WABA ---
+
+    def send_waba_message(device_id:, phone:, message:)
+      post('/v1/waba/send-message', { device_id: device_id, phone: phone, message: message })
+    end
+
+    # --- Devices ---
+
+    def list_devices
+      post('/v1/list-devices', {})
+    end
+
+    def device_status(device_id:)
+      post('/v1/device-status', { device_id: device_id })
+    end
+
+    def device_status_enhanced(device_id:)
+      post('/v1/device-status-enhanced', { device_id: device_id })
+    end
+
+    # --- User ---
+
+    def user_info
+      post('/v1/user-info', {})
+    end
+
+    # --- Contacts ---
+
+    def save_contact(phone:, name: nil, email: nil)
+      body = { phone: phone }
+      body[:name]  = name  if name
+      body[:email] = email if email
+      post('/v1/save-contact', body)
+    end
+
+    # --- OTP ---
+
+    def generate_otp(device_id:, phone:, otp_length: nil, otp_type: nil, custom_otp_message: nil)
+      body = { device_id: device_id, phone: phone }
+      body[:otp_length]       = otp_length        if otp_length
+      body[:otp_type]         = otp_type           if otp_type
+      body[:customOtpMessage] = custom_otp_message if custom_otp_message
+      post('/v1/generate-otp', body)
+    end
+
+    def validate_otp(device_id:, phone:, otp:)
+      post('/v1/validate-otp', { device_id: device_id, phone: phone, otp: otp })
+    end
+
+    # --- OTP V2 ---
+
+    def send_otp_v2(phone:, device_id:, method: nil, app_name: nil, template_code: nil, custom_message: nil)
+      body = { phone: phone, device_id: device_id }
+      body[:method]        = method        if method
+      body[:app_name]      = app_name      if app_name
+      body[:template_code] = template_code if template_code
+      body[:custom_message] = custom_message if custom_message
+      post('/v2/otp/send', body)
+    end
+
+    def verify_otp_v2(phone:, otp_code:)
+      post('/v2/otp/verify', { phone: phone, otp_code: otp_code })
+    end
+
+    # --- Broadcast ---
+
+    def broadcast_message(device_id:, phones:, message:, delay: nil)
+      phones_str = phones.is_a?(Array) ? phones.join(',') : phones
+      body = { device_id: device_id, phones: phones_str, message: message }
+      body[:delay] = delay if delay
+      post('/v1/broadcast-message', body)
+    end
+
+    # --- Deposits ---
+
+    def list_deposits(status: nil)
+      body = {}
+      body[:status] = status if status
+      post('/v1/list-deposits', body)
+    end
+
+    def list_packages
+      post('/v1/list-packages', {})
+    end
+
+    private
+
+    def auth_params
+      { user_code: @user_code, secret: @secret }
+    end
+
+    def post(path, body)
+      uri = URI("#{@base_url}#{path}")
+      http = build_http(uri)
+
+      request = Net::HTTP::Post.new(uri)
+      request['Content-Type'] = 'application/json'
+      request['Accept']       = 'application/json'
+      request.body = JSON.generate(auth_params.merge(body))
+
+      execute(http, request)
+    end
+
+    def post_multipart(path, fields, file_io, file_name)
+      uri      = URI("#{@base_url}#{path}")
+      http     = build_http(uri)
+      boundary = "KirimiRubySDK#{SecureRandom.hex(8)}"
+
+      body_parts = []
+      fields.each do |key, value|
+        body_parts << "--#{boundary}\r\n"
+        body_parts << "Content-Disposition: form-data; name=\"#{key}\"\r\n\r\n"
+        body_parts << "#{value}\r\n"
+      end
+
+      # File part
+      file_data = file_io.read
+      body_parts << "--#{boundary}\r\n"
+      body_parts << "Content-Disposition: form-data; name=\"file\"; filename=\"#{file_name}\"\r\n"
+      body_parts << "Content-Type: application/octet-stream\r\n\r\n"
+      body_parts << file_data
+      body_parts << "\r\n--#{boundary}--\r\n"
+
+      request = Net::HTTP::Post.new(uri)
+      request['Content-Type'] = "multipart/form-data; boundary=#{boundary}"
+      request['Accept']       = 'application/json'
+      request.body = body_parts.join
+
+      execute(http, request)
+    end
+
+    def build_http(uri)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl     = (uri.scheme == 'https')
+      http.read_timeout  = @timeout
+      http.open_timeout  = @timeout
+      http
+    end
+
+    def execute(http, request)
+      response = http.request(request)
+      parse_response(response)
+    rescue Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ETIMEDOUT,
+           Net::OpenTimeout, Net::ReadTimeout, SocketError => e
+      raise Kirimi::NetworkError, "Network error: #{e.message}"
+    end
+
+    def parse_response(response)
+      status = response.code.to_i
+      body   = parse_body(response.body)
+
+      unless (200..299).cover?(status)
+        msg = body.is_a?(Hash) ? (body['message'] || response.message) : response.message
+        raise Kirimi::ApiError.new(status, msg, body)
+      end
+
+      Kirimi::Response.new(body)
+    end
+
+    def parse_body(body)
+      return {} if body.nil? || body.empty?
+
+      JSON.parse(body)
+    rescue JSON::ParserError
+      { 'message' => body }
+    end
+  end
+end
+
+# Lazy require SecureRandom (part of stdlib, always available)
+require 'securerandom'

data/lib/kirimi/errors.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Kirimi
+  class Error < StandardError; end
+
+  class ApiError < Error
+    attr_reader :status_code, :response_data
+
+    def initialize(status_code, message, response_data = nil)
+      super(message)
+      @status_code = status_code
+      @response_data = response_data
+    end
+  end
+
+  class NetworkError < Error; end
+end

data/lib/kirimi/response.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Kirimi
+  class Response
+    attr_reader :success, :data, :message, :raw
+
+    def initialize(hash)
+      @raw = hash
+      @success = hash['success']
+      @data = hash['data']
+      @message = hash['message']
+    end
+
+    def success?
+      @success == true
+    end
+
+    def to_s
+      "#<Kirimi::Response success=#{@success} message=#{@message.inspect}>"
+    end
+
+    def inspect
+      to_s
+    end
+  end
+end

data/lib/kirimi/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Kirimi
+  VERSION = '0.1.0'
+end

data/lib/kirimi.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'kirimi/version'
+require_relative 'kirimi/errors'
+require_relative 'kirimi/response'
+require_relative 'kirimi/client'
+
+# Kirimi Ruby SDK — Official client for the Kirimi WhatsApp API.
+#
+# Usage:
+#   client = Kirimi::Client.new(user_code: 'USER', secret: 'SECRET')
+#   resp   = client.send_message(device_id: 'DEV', phone: '628xxx', message: 'Hello!')
+#   puts resp.success?   # => true
+#   puts resp.data       # => { ... }
+module Kirimi
+end

data/test/client_test.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'json'
+require 'ostruct'
+
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+require 'kirimi'
+
+# Minimal HTTP response stub
+FakeResponse = Struct.new(:code, :body, :message) do
+  def [](key); nil; end
+end
+
+# Captures the last request body sent via Net::HTTP
+module NetHTTPStub
+  @stub_status   = 200
+  @stub_body     = {}
+  @last_body     = nil
+  @last_path     = nil
+
+  class << self
+    attr_accessor :stub_status, :stub_body, :last_body, :last_path
+
+    def setup(status:, body:)
+      @stub_status = status
+      @stub_body   = body
+      @last_body   = nil
+      @last_path   = nil
+    end
+  end
+end
+
+# Monkey-patch Net::HTTP for tests only
+module Net
+  class HTTP
+    def request(req)
+      NetHTTPStub.last_body = JSON.parse(req.body) rescue req.body
+      NetHTTPStub.last_path = req.path
+      FakeResponse.new(
+        NetHTTPStub.stub_status.to_s,
+        NetHTTPStub.stub_body.to_json,
+        'OK'
+      )
+    end
+  end
+end
+
+class ClientTest < Minitest::Test
+  def setup
+    @client = Kirimi::Client.new(user_code: 'USER', secret: 'SECRET')
+  end
+
+  def stub(status: 200, body: { 'success' => true, 'data' => nil, 'message' => 'ok' })
+    NetHTTPStub.setup(status: status, body: body)
+  end
+
+  # ---- send_message ----
+
+  def test_send_message_correct_body
+    stub(body: { 'success' => true, 'data' => { 'id' => 'msg_1' }, 'message' => 'sent' })
+
+    resp = @client.send_message(device_id: 'DEV1', phone: '628111', message: 'Hello!')
+
+    assert_equal 'USER',   NetHTTPStub.last_body['user_code']
+    assert_equal 'SECRET', NetHTTPStub.last_body['secret']
+    assert_equal 'DEV1',   NetHTTPStub.last_body['device_id']
+    assert_equal '628111', NetHTTPStub.last_body['phone']
+    assert_equal 'Hello!', NetHTTPStub.last_body['message']
+    assert_instance_of Kirimi::Response, resp
+    assert resp.success?
+    assert_equal 'msg_1', resp.data['id']
+  end
+
+  def test_send_message_includes_media_url
+    stub
+    @client.send_message(device_id: 'DEV1', phone: '628111', message: 'pic', media_url: 'https://img.example.com/a.jpg')
+    assert_equal 'https://img.example.com/a.jpg', NetHTTPStub.last_body['media_url']
+  end
+
+  def test_send_message_omits_media_url_when_nil
+    stub
+    @client.send_message(device_id: 'DEV1', phone: '628111', message: 'hi')
+    refute NetHTTPStub.last_body.key?('media_url')
+  end
+
+  # ---- generate_otp ----
+
+  def test_generate_otp_with_optional_params
+    stub(body: { 'success' => true, 'data' => { 'otp' => '123456' }, 'message' => 'OTP sent' })
+
+    resp = @client.generate_otp(
+      device_id:          'DEV1',
+      phone:              '628111',
+      otp_length:         6,
+      otp_type:           'numeric',
+      custom_otp_message: 'Your code is {otp}'
+    )
+
+    assert_equal 6,                   NetHTTPStub.last_body['otp_length']
+    assert_equal 'numeric',           NetHTTPStub.last_body['otp_type']
+    assert_equal 'Your code is {otp}', NetHTTPStub.last_body['customOtpMessage']
+    assert resp.success?
+    assert_equal '123456', resp.data['otp']
+  end
+
+  def test_generate_otp_omits_optional_when_nil
+    stub
+    @client.generate_otp(device_id: 'DEV1', phone: '628111')
+    refute NetHTTPStub.last_body.key?('otp_length')
+    refute NetHTTPStub.last_body.key?('customOtpMessage')
+  end
+
+  # ---- error handling ----
+
+  def test_raises_api_error_on_401
+    stub(status: 401, body: { 'success' => false, 'message' => 'Unauthorized' })
+
+    err = assert_raises(Kirimi::ApiError) { @client.user_info }
+    assert_equal 401,            err.status_code
+    assert_equal 'Unauthorized', err.message
+  end
+
+  def test_raises_api_error_on_500
+    stub(status: 500, body: { 'success' => false, 'message' => 'Server Error' })
+
+    err = assert_raises(Kirimi::ApiError) { @client.list_devices }
+    assert_equal 500, err.status_code
+  end
+
+  # ---- response wrapping ----
+
+  def test_response_wraps_data_correctly
+    stub(body: { 'success' => true, 'data' => { 'name' => 'John' }, 'message' => 'OK' })
+
+    resp = @client.user_info
+
+    assert_instance_of Kirimi::Response, resp
+    assert resp.success?
+    assert_equal true,   resp.success
+    assert_equal 'John', resp.data['name']
+    assert_equal 'OK',   resp.message
+    assert_instance_of Hash, resp.raw
+  end
+
+  # ---- broadcast phones array ----
+
+  def test_broadcast_joins_phones_array
+    stub
+    @client.broadcast_message(device_id: 'DEV1', phones: %w[628111 628222 628333], message: 'Promo!')
+    assert_equal '628111,628222,628333', NetHTTPStub.last_body['phones']
+  end
+
+  def test_broadcast_accepts_phones_string
+    stub
+    @client.broadcast_message(device_id: 'DEV1', phones: '628111,628222', message: 'Hi')
+    assert_equal '628111,628222', NetHTTPStub.last_body['phones']
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: kirimi
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kirimi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-04-14 00:00:00.000000000 Z
+dependencies:
+- !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 WhatsApp messages, OTP, broadcasts, and more via the Kirimi API.
+email:
+- support@kirimi.id
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- kirimi.gemspec
+- lib/kirimi.rb
+- lib/kirimi/client.rb
+- lib/kirimi/errors.rb
+- lib/kirimi/response.rb
+- lib/kirimi/version.rb
+- test/client_test.rb
+homepage: https://github.com/kiriminow/kirimi-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/kiriminow/kirimi-ruby
+  source_code_uri: https://github.com/kiriminow/kirimi-ruby
+  changelog_uri: https://github.com/kiriminow/kirimi-ruby/blob/main/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Official Ruby SDK for Kirimi WhatsApp API
+test_files:
+- test/client_test.rb