bzapper 0.7.0

data/lib/bzapper/transport.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module Bzapper
+  # URL de produção da API (padrão do {Client}). Em dev: `http://localhost:8080`.
+  DEFAULT_BASE_URL = "https://api.bzapper.com.br"
+  # Vai em `X-Bzapper-Client` e `User-Agent`. É por ele que a API sabe qual versão da SDK a
+  # conta roda — e dispara o aviso "atualize sua integração" só para quem precisa.
+  CLIENT_ID = "bzapper-ruby/#{VERSION}".freeze
+  # Segundos por tentativa.
+  DEFAULT_TIMEOUT = 30
+  # Novas tentativas além da primeira.
+  DEFAULT_MAX_RETRIES = 2
+
+  # Faz UMA chamada lógica: 1 tentativa + até `max_retries` novas tentativas, com os mesmos
+  # `X-Request-Id` e `Idempotency-Key`. Sem estado mutável entre chamadas (uma conexão por
+  # tentativa), então um {Client} pode ser compartilhado entre threads.
+  # @api private
+  class Transport
+    RETRY_STATUSES = [429, 502, 503, 504].freeze
+    WRITE_METHODS = %w[POST PUT PATCH DELETE].freeze
+    MAX_RETRY_AFTER = 60.0
+    MAX_BACKOFF = 8.0
+
+    # Métodos que "esperam" corpo: sem corpo, vão com `Content-Length: 0` (e sem Content-Type).
+    BODY_METHODS = %w[POST PUT PATCH].freeze
+
+    # Falhas de transporte que viram {NetworkError} (e são repetidas). `Net::OpenTimeout` e
+    # `Net::ReadTimeout` são `Timeout::Error`; `ECONNREFUSED`/`ECONNRESET` são `SystemCallError`.
+    NETWORK_ERRORS = [
+      SocketError, SystemCallError, IOError, Timeout::Error, OpenSSL::SSL::SSLError,
+      Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError
+    ].tap { |list| list << Zlib::Error if defined?(Zlib::Error) }.freeze
+
+    attr_reader :base_url, :timeout, :max_retries, :locale, :project_id
+    # Espera entre tentativas (`#call(segundos)`). Substituível: os testes não dormem.
+    attr_accessor :sleeper
+
+    def initialize(api_key, base_url:, timeout:, max_retries:, locale: nil, project_id: nil, sleeper: nil)
+      @api_key = api_key
+      @base_url = base_url.sub(%r{/+\z}, "")
+      begin
+        @uri = URI.parse(@base_url)
+      rescue URI::InvalidURIError
+        @uri = nil
+      end
+      unless @uri.is_a?(URI::HTTP) && @uri.hostname && !@uri.hostname.empty?
+        raise ArgumentError, "Bzapper: base_url inválida #{base_url.inspect} (use http:// ou https://)."
+      end
+
+      @base_path = @uri.path.to_s
+      @timeout = timeout
+      @max_retries = max_retries
+      @locale = present(locale)
+      @project_id = present(project_id)
+      @sleeper = sleeper || ->(seconds) { sleep(seconds) }
+    end
+
+    # `Retry-After` em segundos (número ou data HTTP); `nil` se ausente/inválido.
+    # @return [Integer, Float, nil]
+    def self.parse_retry_after(raw)
+      return nil if raw.nil?
+
+      text = raw.to_s.strip
+      return nil if text.empty?
+
+      seconds =
+        if text.match?(/\A\d+(?:\.\d+)?\z/)
+          text.to_f
+        else
+          begin
+            Time.httpdate(text) - Time.now
+          rescue ArgumentError
+            return nil
+          end
+        end
+      return nil if seconds.nan? || seconds.infinite?
+
+      seconds = 0.0 if seconds.negative?
+      seconds == seconds.floor ? seconds.to_i : seconds
+    end
+
+    # `min(8, 0.5 × 2^tentativa)` s + jitter de até 25%.
+    def self.backoff(attempt)
+      base = [MAX_BACKOFF, 0.5 * (2**attempt)].min
+      base + (Random.rand * base * 0.25)
+    end
+
+    # Espera antes da próxima tentativa: `Retry-After` (teto 60 s) ou backoff exponencial.
+    def retry_delay(attempt, retry_after)
+      seconds = self.class.parse_retry_after(retry_after)
+      return [seconds.to_f, MAX_RETRY_AFTER].min unless seconds.nil?
+
+      self.class.backoff(attempt)
+    end
+
+    # Executa a chamada e devolve o JSON decodificado da resposta (`nil` sem corpo).
+    #
+    # `body: nil` significa SEM corpo JSON; `multipart:` é um {Upload}.
+    # @raise [Bzapper::Error]
+    def request(method, path, query: nil, body: nil, multipart: nil, idempotency_key: nil, timeout: nil)
+      method = method.to_s.upcase
+      per_try = timeout.nil? ? @timeout : timeout
+      unless per_try.is_a?(Numeric) && per_try.positive?
+        raise ArgumentError, "timeout precisa ser > 0 (segundos)."
+      end
+
+      target = @base_path + path + Codec.query_string(query)
+      request_id = SecureRandom.uuid.delete("-")
+      headers = {
+        "Authorization" => "Bearer #{@api_key}",
+        "Accept" => "application/json",
+        "X-Bzapper-Client" => CLIENT_ID,
+        "User-Agent" => CLIENT_ID,
+        # Mesmo id em todas as tentativas desta chamada: é como o suporte correlaciona.
+        "X-Request-Id" => request_id
+      }
+      headers["Accept-Language"] = @locale if @locale
+      headers["X-Project-Id"] = @project_id if @project_id
+      if WRITE_METHODS.include?(method)
+        # Mesma chave em todas as tentativas: a API devolve a resposta original
+        # (Idempotent-Replayed: true) em vez de executar de novo.
+        key = idempotency_key.to_s
+        headers["Idempotency-Key"] = key.empty? ? SecureRandom.uuid : key
+      end
+      payload = nil
+      if multipart
+        payload, headers["Content-Type"] = multipart.encode
+      elsif !body.nil?
+        payload = JSON.generate(Codec.jsonable(body))
+        headers["Content-Type"] = "application/json"
+      end
+
+      attempt = 0
+      while true # rubocop:disable Style/InfiniteLoop -- `loop` engoliria um StopIteration do sleeper
+        begin
+          status, resp_headers, raw = perform(method, target, headers, payload, per_try)
+        rescue *NETWORK_ERRORS => e
+          if attempt < @max_retries
+            @sleeper.call(self.class.backoff(attempt))
+            attempt += 1
+            next
+          end
+          raise NetworkError.new(
+            "NETWORK_ERROR: falha ao falar com #{@base_url} (#{e.class}: #{e.message})",
+            request_id: request_id
+          )
+        end
+
+        return decode(status, resp_headers, raw, request_id) if status.between?(200, 299)
+
+        if RETRY_STATUSES.include?(status) && attempt < @max_retries
+          @sleeper.call(retry_delay(attempt, resp_headers["retry-after"]))
+          attempt += 1
+          next
+        end
+        raise build_error(status, resp_headers, raw, request_id)
+      end
+    end
+
+    def inspect
+      "#<Bzapper::Transport base_url=#{@base_url.inspect}>"
+    end
+
+    private
+
+    def perform(method, target, headers, payload, timeout)
+      http = Net::HTTP.new(@uri.hostname, @uri.port)
+      http.use_ssl = @uri.scheme == "https"
+      http.open_timeout = timeout
+      http.read_timeout = timeout
+      http.write_timeout = timeout
+      # O Net::HTTP repete sozinho GET/PUT/DELETE uma vez em certas falhas; quem decide
+      # novas tentativas (e conta) é esta classe.
+      http.max_retries = 0
+      # Requisição genérica, e não Net::HTTP::Post/Put: sem corpo, aquelas viram `body = ""` +
+      # `Content-Type: application/x-www-form-urlencoded` por conta própria.
+      req = Net::HTTPGenericRequest.new(method, !payload.nil?, true, target, headers)
+      if payload.nil?
+        req["Content-Length"] = "0" if BODY_METHODS.include?(method)
+      else
+        req.body = payload
+      end
+      response = http.start { |conn| conn.request(req) }
+      resp_headers = {}
+      response.each_header { |name, value| resp_headers[name] = value }
+      [response.code.to_i, resp_headers, response.body.to_s]
+    end
+
+    # 2xx → o JSON inteiro (`nil` quando não há corpo, ex.: 204). Corpo não vazio que não é JSON
+    # → `INVALID_RESPONSE` — nunca "sucesso sem dados" calado (proxy que responde 200 com HTML).
+    def decode(status, headers, raw, sent_request_id)
+      payload, text, ok = Codec.decode_json(raw)
+      return nil if text.strip.empty?
+      return payload if ok
+
+      shown = text.strip[0, 200]
+      raise Error.new(
+        "INVALID_RESPONSE (HTTP #{status}): a resposta não é JSON: #{shown.inspect}",
+        code: "INVALID_RESPONSE",
+        status: status,
+        request_id: present(headers["x-request-id"]) || sent_request_id,
+        body: text
+      )
+    end
+
+    # Resposta fora de 2xx → erro. Corpo `{code, message, locale}`; `request_id`: header da
+    # resposta → o id que a SDK enviou.
+    def build_error(status, headers, raw, sent_request_id)
+      payload, text, ok = Codec.decode_json(raw)
+      code = nil
+      human = nil
+      locale = nil
+
+      if ok && payload.is_a?(Hash)
+        err = payload["code"]
+        err = payload["error"] unless err.is_a?(String) && !err.empty?
+        code = err if err.is_a?(String) && !err.empty?
+        msg = payload["message"]
+        human = msg if msg.is_a?(String) && !msg.empty?
+        locale = payload["locale"] if payload["locale"].is_a?(String)
+      elsif !text.strip.empty?
+        human = text.strip[0, 200]
+      end
+
+      code ||= "HTTP_#{status}"
+      request_id = present(headers["x-request-id"]) || sent_request_id
+      retry_after = status == 429 ? self.class.parse_retry_after(headers["retry-after"]) : nil
+      required_scope = status == 403 ? present(headers["x-required-scope"]) : nil
+
+      # `message` do padrão: `body.message`, senão o `code` (detalhes em #detailed_message).
+      Error.class_for(status).new(
+        human || code,
+        code: code,
+        status: status,
+        request_id: request_id,
+        retry_after: retry_after,
+        required_scope: required_scope,
+        locale: locale,
+        body: ok ? payload : present(text)
+      )
+    end
+
+    def present(value)
+      text = value.to_s
+      text.empty? ? nil : text
+    end
+  end
+end

data/lib/bzapper/unset.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Bzapper
+  # Marca de argumento **não informado** — diferente de `nil`, que vai como `null` e LIMPA o
+  # campo na API. É o valor padrão dos keyword args opcionais de corpo; você nunca precisa
+  # usá-la. Existe uma única instância: {Bzapper::UNSET}.
+  class Unset
+    def inspect
+      "Bzapper::UNSET"
+    end
+    alias to_s inspect
+
+    # Continua sendo a mesma instância (comparação por identidade).
+    def dup
+      self
+    end
+
+    # Continua sendo a mesma instância (comparação por identidade).
+    def clone(freeze: true) # rubocop:disable Lint/UnusedMethodArgument
+      self
+    end
+  end
+
+  # Valor padrão dos keyword args opcionais de corpo: "não envie este campo".
+  UNSET = Unset.new.freeze
+  Unset.private_class_method :new
+end

data/lib/bzapper/upload.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Bzapper
+  # Arquivo de um upload `multipart/form-data` (logo da marca, logo do projeto, mídia de
+  # campanha). Montado pela SDK a partir de `file:`, `filename:` e `content_type:`.
+  # @api private
+  class Upload
+    DEFAULT_CONTENT_TYPE = "application/octet-stream"
+
+    attr_reader :field, :data, :filename, :content_type
+
+    # @param field [String] nome do campo do formulário (`file`).
+    # @param file [String, IO, Pathname] bytes, um IO (lido inteiro agora) ou o caminho no disco.
+    # @param filename [String, nil] padrão: o nome do caminho/IO, senão `"file"`.
+    # @param content_type [String, nil] padrão: `application/octet-stream`.
+    # @raise [ArgumentError] arquivo ausente ou nome inválido.
+    def initialize(field, file, filename: nil, content_type: nil)
+      raise ArgumentError, "file é obrigatório (bytes, IO ou Pathname)." if file.nil? || file.equal?(UNSET)
+
+      guessed = nil
+      if defined?(::Pathname) && file.is_a?(::Pathname)
+        guessed = file.basename.to_s
+        @data = File.binread(file.to_s)
+      elsif file.respond_to?(:read)
+        guessed = File.basename(file.path.to_s) if file.respond_to?(:path) && file.path
+        @data = file.read.to_s.b
+      elsif file.is_a?(String)
+        @data = file.b
+      else
+        raise TypeError, "file precisa ser String (bytes), IO ou Pathname (recebeu #{file.class})."
+      end
+
+      @field = field
+      @filename = (filename || guessed).to_s
+      @filename = "file" if @filename.empty?
+      if @filename.match?(/[\r\n"]/)
+        raise ArgumentError, "filename não pode ter aspas nem quebra de linha: #{@filename.inspect}"
+      end
+
+      @content_type = (content_type || DEFAULT_CONTENT_TYPE).to_s
+      raise ArgumentError, "content_type inválido: #{@content_type.inspect}" if @content_type.match?(/[\r\n]/)
+    end
+
+    # Corpo `multipart/form-data` → `[bytes, content_type_do_cabeçalho]`. A fronteira é gerada
+    # uma vez por chamada lógica (as novas tentativas reenviam os mesmos bytes).
+    def encode
+      boundary = "bzapper-#{SecureRandom.hex(16)}"
+      body = +"".b
+      body << "--#{boundary}\r\n".b
+      body << "Content-Disposition: form-data; name=\"#{@field}\"; filename=\"#{@filename}\"\r\n".b
+      body << "Content-Type: #{@content_type}\r\n\r\n".b
+      body << @data
+      body << "\r\n--#{boundary}--\r\n".b
+      [body, "multipart/form-data; boundary=#{boundary}"]
+    end
+
+    def inspect
+      "#<Bzapper::Upload field=#{@field.inspect} filename=#{@filename.inspect} bytes=#{@data.bytesize}>"
+    end
+  end
+end

data/lib/bzapper/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Bzapper
+  # Versão da gem. O `scripts/release-sdks.sh` do monorepo bumpa a linha abaixo por regex
+  # (ancorada no início da linha) e o `bzapper.gemspec` lê daqui — não mude o formato dela.
+  VERSION = "0.7.0"
+end

data/lib/bzapper/webhook.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module Bzapper
+  # Recebimento de webhooks — local, sem rede.
+  #
+  # A API assina cada entrega com `X-Bzapper-Signature: sha256=<hex>`, onde o hex é
+  # `HMAC-SHA256(secret, corpo_cru)`. Também manda `X-Bzapper-Event-Id` e
+  # `X-Bzapper-Event-Type`. Verifique SEMPRE o corpo **cru** (os bytes recebidos), nunca o JSON
+  # re-serializado.
+  #
+  # @example Rack/Rails
+  #   raw = request.body.read
+  #   event = Bzapper::Webhook.construct_event(ENV["BZAPPER_WEBHOOK_SECRET"], raw,
+  #                                            request.get_header("HTTP_X_BZAPPER_SIGNATURE"))
+  #   puts event.type, event.payload["body"]
+  #
+  # Idempotência: cada evento traz um `event.id` estável — guarde os ids processados e ignore
+  # repetições (a API pode reentregar).
+  module Webhook
+    SIGNATURE_HEADER = "X-Bzapper-Signature"
+    EVENT_ID_HEADER = "X-Bzapper-Event-Id"
+    EVENT_TYPE_HEADER = "X-Bzapper-Event-Type"
+    PREFIX = "sha256="
+
+    # Tipos de evento que a API pode entregar (referência).
+    EVENT_TYPES = %w[
+      message.received message.sent message.delivered message.read message.failed
+      instance.connected instance.disconnected instance.banned instance.logged_out
+      instance.warming instance.status
+      group.joined group.left group.participant_added group.participant_removed
+      group.participant_promoted group.participant_demoted
+      group.subject_changed group.description_changed
+      connect.completed connect.suspended connect.resumed connect.revoked
+    ].freeze
+
+    # Ciclo de vida de uma conexão do bZapper Connect — só no webhook do PARCEIRO.
+    CONNECT_EVENT_TYPES = %w[connect.completed connect.suspended connect.resumed connect.revoked].freeze
+
+    module_function
+
+    # Assinatura esperada para um corpo (`sha256=<hex>`).
+    # @param secret [String] o segredo do webhook (devolvido uma vez por `create_webhook`).
+    # @param raw_body [String] o corpo cru.
+    # @return [String]
+    # @raise [ArgumentError] segredo vazio.
+    def sign(secret, raw_body)
+      raise ArgumentError, "secret do webhook é obrigatório." if secret.nil? || secret.to_s.empty?
+
+      PREFIX + OpenSSL::HMAC.hexdigest("SHA256", secret.to_s.b, raw_body.to_s.b)
+    end
+
+    # `true` sse a assinatura confere com o HMAC do corpo **cru**. Comparação em tempo constante.
+    # @param secret [String]
+    # @param raw_body [String] os bytes recebidos, exatamente.
+    # @param signature [String, nil] o valor do header `X-Bzapper-Signature`.
+    # @return [Boolean]
+    def verify(secret, raw_body, signature)
+      return false if secret.nil? || secret.to_s.empty?
+      return false if signature.nil? || signature.to_s.empty?
+
+      expected = sign(secret, raw_body)
+      given = signature.to_s.strip.b
+      return false unless given.bytesize == expected.bytesize
+
+      OpenSSL.fixed_length_secure_compare(expected, given)
+    end
+
+    # Verifica a assinatura e decodifica o evento.
+    # @return [Event]
+    # @raise [Bzapper::SignatureError] assinatura ausente ou inválida — NÃO processe.
+    # @raise [JSON::ParserError] corpo assinado que não é JSON.
+    def construct_event(secret, raw_body, signature)
+      raise SignatureError, "assinatura de webhook inválida" unless verify(secret, raw_body, signature)
+
+      text = raw_body.to_s.dup.force_encoding(::Encoding::UTF_8)
+      Event.new(JSON.parse(text))
+    end
+
+    # Evento de webhook decodificado (o envelope entregue). Campos desconhecidos continuam em
+    # {#raw}.
+    class Event
+      # @return [Hash] o envelope inteiro, como veio.
+      attr_reader :raw
+
+      def initialize(raw)
+        @raw = raw.is_a?(Hash) ? raw : {}
+      end
+
+      # @return [String] id estável do evento (use para idempotência).
+      def id
+        @raw["event_id"].to_s
+      end
+
+      # @return [String] tipo do evento (`message.received`, `instance.connected`…).
+      def type
+        @raw["event_type"].to_s
+      end
+
+      # @return [String, nil]
+      def timestamp
+        @raw["timestamp"]
+      end
+
+      # @return [String, nil]
+      def instance_id
+        @raw["instance_id"]
+      end
+
+      # @return [String, nil] a correlação que você mandou no envio.
+      def client_reference
+        @raw["client_reference"]
+      end
+
+      # @return [Hash, nil] `{"jid", "name"}` quando o evento aconteceu num grupo.
+      def group
+        @raw["group"].is_a?(Hash) ? @raw["group"] : nil
+      end
+
+      # @return [Hash, nil] `{"jid", "lid", "name", "phone"}` de quem enviou/disparou.
+      def sender
+        @raw["sender"].is_a?(Hash) ? @raw["sender"] : nil
+      end
+
+      # @return [Array<String>]
+      def mentions
+        Array(@raw["mentions"])
+      end
+
+      # @return [Hash] dados específicos do tipo de evento.
+      def payload
+        @raw["payload"].is_a?(Hash) ? @raw["payload"] : {}
+      end
+
+      # @return [Hash, nil] conexão do Connect (só no webhook do parceiro).
+      def connection
+        @raw["connection"].is_a?(Hash) ? @raw["connection"] : nil
+      end
+
+      # @return [Hash]
+      def to_h
+        @raw
+      end
+
+      def [](key)
+        @raw[key.to_s]
+      end
+
+      def inspect
+        "#<Bzapper::Webhook::Event id=#{id.inspect} type=#{type.inspect}>"
+      end
+    end
+
+    # Verifica, decodifica e despacha entregas para handlers por tipo de evento.
+    #
+    # @example
+    #   router = Bzapper::Webhook::Router.new(ENV.fetch("BZAPPER_WEBHOOK_SECRET"))
+    #   router.on("message.received") { |event| puts event.payload["body"] }
+    #   router.handle(raw_body, signature) # SignatureError se não confere
+    class Router
+      def initialize(secret)
+        raise ArgumentError, "Bzapper::Webhook::Router: secret é obrigatório." if secret.nil? || secret.to_s.empty?
+
+        @secret = secret
+        @handlers = Hash.new { |hash, key| hash[key] = [] }
+        @any = []
+      end
+
+      # Registra um handler para um tipo de evento.
+      def on(event_type, callable = nil, &block)
+        @handlers[event_type.to_s] << (callable || block || raise(ArgumentError, "handler ausente"))
+        self
+      end
+
+      # Registra um handler para TODO evento.
+      def on_any(callable = nil, &block)
+        @any << (callable || block || raise(ArgumentError, "handler ausente"))
+        self
+      end
+
+      # Verifica + decodifica + despacha. Devolve o evento.
+      # @raise [Bzapper::SignatureError]
+      def handle(raw_body, signature)
+        event = Webhook.construct_event(@secret, raw_body, signature)
+        @handlers.fetch(event.type, []).each { |handler| handler.call(event) }
+        @any.each { |handler| handler.call(event) }
+        event
+      end
+
+      def inspect
+        "#<Bzapper::Webhook::Router>"
+      end
+    end
+  end
+end

data/lib/bzapper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# SDK oficial em Ruby da API do bZapper (WhatsApp): mensagens, números, grupos, contatos,
+# campanhas, webhooks e o bZapper Connect. Só biblioteca padrão (net/http, json, openssl,
+# securerandom).
+#
+# @example
+#   require "bzapper"
+#
+#   client = Bzapper::Client.new(ENV.fetch("BZAPPER_API_KEY"))
+#   client.messages.send_text(to: "5511999990000", body: "Olá!")
+module Bzapper
+end
+
+require "json"
+require "net/http"
+require "openssl"
+require "securerandom"
+require "time"
+require "uri"
+
+require_relative "bzapper/version"
+require_relative "bzapper/unset"
+require_relative "bzapper/errors"
+require_relative "bzapper/codec"
+require_relative "bzapper/upload"
+require_relative "bzapper/transport"
+require_relative "bzapper/resources"
+require_relative "bzapper/client"
+require_relative "bzapper/webhook"

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: bzapper
+version: !ruby/object:Gem::Version
+  version: 0.7.0
+platform: ruby
+authors:
+- Berni Software
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Mensagens (todos os tipos, OTP), números e QR, grupos, contatos, campanhas,
+  webhooks com verificação de assinatura e bZapper Connect. Zero dependências de runtime,
+  novas tentativas e idempotência automáticas.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/bzapper.rb
+- lib/bzapper/client.rb
+- lib/bzapper/codec.rb
+- lib/bzapper/errors.rb
+- lib/bzapper/resources.rb
+- lib/bzapper/resources/accounts.rb
+- lib/bzapper/resources/advanced.rb
+- lib/bzapper/resources/advisories.rb
+- lib/bzapper/resources/base.rb
+- lib/bzapper/resources/billing.rb
+- lib/bzapper/resources/campaigns.rb
+- lib/bzapper/resources/connect.rb
+- lib/bzapper/resources/contacts.rb
+- lib/bzapper/resources/conversations.rb
+- lib/bzapper/resources/groups.rb
+- lib/bzapper/resources/instances.rb
+- lib/bzapper/resources/messages.rb
+- lib/bzapper/resources/partner.rb
+- lib/bzapper/resources/pools.rb
+- lib/bzapper/resources/scheduling.rb
+- lib/bzapper/resources/system.rb
+- lib/bzapper/resources/usage.rb
+- lib/bzapper/resources/webhooks.rb
+- lib/bzapper/transport.rb
+- lib/bzapper/unset.rb
+- lib/bzapper/upload.rb
+- lib/bzapper/version.rb
+- lib/bzapper/webhook.rb
+homepage: https://bzapper.com.br
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://bzapper.com.br
+  source_code_uri: https://github.com/bernisoftware/bzapper-ruby
+  bug_tracker_uri: https://github.com/bernisoftware/bzapper-ruby/issues
+  documentation_uri: https://github.com/bernisoftware/bzapper-ruby#readme
+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.6.9
+specification_version: 4
+summary: SDK oficial da API do bZapper (WhatsApp)
+test_files: []