mailinator_client 1.0.3 → 1.0.5

data/lib/mailinator_client/webhooks.rb

@@ -0,0 +1,281 @@
+# The MIT License (MIT)
+#
+# Copyright (c) 2024 Manybrain, Inc.
+#
+# 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.
+
+require "json"
+
+module MailinatorClient
+
+  # Class containing all the actions for the Webhooks Resource
+  class Webhooks
+
+    def initialize(client)
+      @client = client
+    end
+
+    # This command will deliver the message to the :to inbox that was set into request object
+    #
+    # Parameters:
+    # *  {string} webhook - The Webhook object
+    #
+    # Responses:
+    # *  PublicWebhookResponse (https://manybrain.github.io/m8rdocs/#public-webhook)
+    def public_webhook(params = {})
+      query_params = {}
+      headers = {}
+      body = nil
+
+      raise ArgumentError.new("webhook is required") unless params.has_key?(:webhook)
+
+      body = params[:webhook] if params.has_key?(:webhook)
+
+      path = "/domains/public/webhook"
+
+      response = @client.request(
+        method: :post,
+        path: path,
+        query: query_params,
+        headers: headers,
+        body: body)
+    end
+    
+    # This command will deliver the message to the :inbox inbox
+    # Note that if the Mailinator system cannot determine the destination inbox via the URL or a "to" field in the payload, the message will be rejected.
+    # If the message contains a "from" and "subject" field, these will be visible on the inbox page.
+    #
+    # Parameters:
+    # *  {string} inbox - inbox
+    # *  {string} webhook - The Webhook object
+    #
+    # Responses:
+    # *  PublicWebhookResponse (https://manybrain.github.io/m8rdocs/#public-inbox-webhook)
+    def public_inbox_webhook(params = {})
+      query_params = {}
+      headers = {}
+      body = nil
+
+      raise ArgumentError.new("inbox is required") unless params.has_key?(:inbox)
+      raise ArgumentError.new("webhook is required") unless params.has_key?(:webhook)
+
+      body = params[:webhook] if params.has_key?(:webhook)
+
+      path = "/domains/public/webhook/#{params[:inbox]}"
+
+      response = @client.request(
+        method: :post,
+        path: path,
+        query: query_params,
+        headers: headers,
+        body: body)
+    end
+    
+    # If you have a Twilio account which receives incoming SMS messages. You may direct those messages through this facility to inject those messages into the Mailinator system.
+    #
+    # Parameters:
+    # *  {string} customService - custom service name
+    # *  {string} webhook - The Webhook object
+    #
+    # Responses:
+    # *  PublicWebhookResponse (https://manybrain.github.io/m8rdocs/#public-custom-service-webhook)
+    def public_custom_service_webhook(params = {})
+      query_params = {}
+      headers = {}
+      body = nil
+
+      raise ArgumentError.new("customService is required") unless params.has_key?(:customService)
+      raise ArgumentError.new("webhook is required") unless params.has_key?(:webhook)
+
+      body = params[:webhook] if params.has_key?(:webhook)
+
+      path = "/domains/public/#{params[:customService]}"
+
+      response = @client.request(
+        method: :post,
+        path: path,
+        query: query_params,
+        headers: headers,
+        body: body)
+    end
+
+    # The SMS message will arrive in the Public Mailinator inbox corresponding to the Twilio Phone Number. (only the digits, if a plus sign precedes the number it will be removed)
+    # If you wish the message to arrive in a different inbox, you may append the destination inbox to the URL.
+    #
+    # Parameters:
+    # *  {string} inbox - inbox
+    # *  {string} customService - custom service name
+    # *  {string} webhook - The Webhook object
+    #
+    # Responses:
+    # *  PublicWebhookResponse (https://manybrain.github.io/m8rdocs/#public-custom-service-inbox-webhook)
+    def public_custom_service_inbox_webhook(params = {})
+      query_params = {}
+      headers = {}
+      body = nil
+
+      raise ArgumentError.new("customService is required") unless params.has_key?(:customService)
+      raise ArgumentError.new("inbox is required") unless params.has_key?(:inbox)
+      raise ArgumentError.new("webhook is required") unless params.has_key?(:webhook)
+
+      body = params[:webhook] if params.has_key?(:webhook)
+
+      path = "/domains/public/#{params[:customService]}/#{params[:inbox]}"
+
+      response = @client.request(
+        method: :post,
+        path: path,
+        query: query_params,
+        headers: headers,
+        body: body)
+    end
+    
+    # This command will Webhook messages into your Private Domain
+    # The incoming Webhook will arrive in the inbox designated by the "to" field in the incoming request payload.
+    # Webhooks into your Private System do NOT use your regular API Token.
+    # This is because a typical use case is to enter the Webhook URL into 3rd-party systems(i.e.Twilio, Zapier, IFTTT, etc) and you should never give out your API Token.
+    # Check your Team Settings where you can create "Webhook Tokens" designed for this purpose.
+    #
+    # Parameters:
+    # *  {string} whToken - webhook token
+    # *  {string} webhook - The Webhook object
+    #
+    # Responses:
+    # *  PrivateWebhookResponse (https://manybrain.github.io/m8rdocs/#private-webhook)
+    def private_webhook(params = {})
+      query_params = {}
+      headers = {}
+      body = nil
+
+      raise ArgumentError.new("whToken is required") unless params.has_key?(:whToken)
+      raise ArgumentError.new("webhook is required") unless params.has_key?(:webhook)
+
+      body = params[:webhook] if params.has_key?(:webhook)
+
+      path = "/domains/#{params[:whToken]}/webhook"
+
+      response = @client.request(
+        method: :post,
+        path: path,
+        query: query_params,
+        headers: headers,
+        body: body)
+    end
+    
+    # This command will deliver the message to the :inbox inbox
+    # Incoming Webhooks are delivered to Mailinator inboxes and from that point onward are not notably different than other messages in the system (i.e. emails). 
+    # As normal, Mailinator will list all messages in the Inbox page and via the Inbox API calls. 
+    # If the incoming JSON payload does not contain a "from" or "subject", then dummy values will be inserted in these fields.
+    # You may retrieve such messages via the Web Interface, the API, or the Rule System
+    #
+    # Parameters:
+    # *  {string} whToken - webhook token
+    # *  {string} inbox - inbox
+    # *  {string} webhook - The Webhook object
+    #
+    # Responses:
+    # *  PrivateWebhookResponse (https://manybrain.github.io/m8rdocs/#private-inbox-webhook)
+    def private_inbox_webhook(params = {})
+      query_params = {}
+      headers = {}
+      body = nil
+
+      raise ArgumentError.new("whToken is required") unless params.has_key?(:whToken)
+      raise ArgumentError.new("inbox is required") unless params.has_key?(:inbox)
+      raise ArgumentError.new("webhook is required") unless params.has_key?(:webhook)
+
+      body = params[:webhook] if params.has_key?(:webhook)
+
+      path = "/domains/#{params[:whToken]}/webhook/#{params[:inbox]}"
+
+      response = @client.request(
+        method: :post,
+        path: path,
+        query: query_params,
+        headers: headers,
+        body: body)
+    end
+    
+    # If you have a Twilio account which receives incoming SMS messages. You may direct those messages through this facility to inject those messages into the Mailinator system.
+    # Mailinator intends to apply specific mappings for certain services that commonly publish webhooks.
+    # If you test incoming Messages to SMS numbers via Twilio, you may use this endpoint to correctly map "to", "from", and "subject" of those messages to the Mailinator system.By default, the destination inbox is the Twilio phone number.
+    #
+    # Parameters:
+    # *  {string} whToken - webhook token
+    # *  {string} customService - custom service name
+    # *  {string} webhook - The Webhook object
+    #
+    # Responses:
+    # *  PrivateWebhookResponse (https://manybrain.github.io/m8rdocs/#private-custom-service-webhook)
+    def private_custom_service_webhook(params = {})
+      query_params = {}
+      headers = {}
+      body = nil
+
+      raise ArgumentError.new("whToken is required") unless params.has_key?(:whToken)
+      raise ArgumentError.new("customService is required") unless params.has_key?(:customService)
+      raise ArgumentError.new("webhook is required") unless params.has_key?(:webhook)
+
+      body = params[:webhook] if params.has_key?(:webhook)
+
+      path = "/domains/#{params[:whToken]}/#{params[:customService]}"
+
+      response = @client.request(
+        method: :post,
+        path: path,
+        query: query_params,
+        headers: headers,
+        body: body)
+    end
+
+    # The SMS message will arrive in the Private Mailinator inbox corresponding to the Twilio Phone Number. (only the digits, if a plus sign precedes the number it will be removed) 
+    # If you wish the message to arrive in a different inbox, you may append the destination inbox to the URL.
+    #
+    # Parameters:
+    # *  {string} whToken - webhook token
+    # *  {string} inbox - inbox
+    # *  {string} customService - custom service name
+    # *  {string} webhook - The Webhook object
+    #
+    # Responses:
+    # *  PrivateWebhookResponse (https://manybrain.github.io/m8rdocs/#private-custom-service-inbox-webhook)
+    def private_custom_service_inbox_webhook(params = {})
+      query_params = {}
+      headers = {}
+      body = nil
+
+      raise ArgumentError.new("whToken is required") unless params.has_key?(:whToken)
+      raise ArgumentError.new("customService is required") unless params.has_key?(:customService)
+      raise ArgumentError.new("inbox is required") unless params.has_key?(:inbox)
+      raise ArgumentError.new("webhook is required") unless params.has_key?(:webhook)
+
+      body = params[:webhook] if params.has_key?(:webhook)
+
+      path = "/domains/#{params[:whToken]}/#{params[:customService]}/#{params[:inbox]}"
+
+      response = @client.request(
+        method: :post,
+        path: path,
+        query: query_params,
+        headers: headers,
+        body: body)
+    end
+    
+  end
+end

data/lib/mailinator_client.rb

@@ -1,6 +1,6 @@
 # The MIT License (MIT)
 #
-# Copyright (c) 2020 Manybrain, Inc.
+# Copyright (c) 2024 Manybrain, Inc.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -23,10 +23,12 @@
 require_relative "mailinator_client/version"
 require_relative "mailinator_client/error"
 require_relative "mailinator_client/utils"
+require_relative "mailinator_client/authenticators"
 require_relative "mailinator_client/domains"
 require_relative "mailinator_client/stats"
 require_relative "mailinator_client/messages"
 require_relative "mailinator_client/rules"
+require_relative "mailinator_client/webhooks"
 require_relative "mailinator_client/client"
 
 module MailinatorClient

data/test/mailinator_client_api_test.rb

@@ -11,12 +11,33 @@ class MailinatorClientApiTest < MiniTest::Test
       @messageIdWithAttachment = "MAILINATOR_TEST_MESSAGE_WITH_ATTACHMENT_ID"
       @attachmentId = "MAILINATOR_TEST_ATTACHMENT_ID"
       @deleteDomain = "MAILINATOR_TEST_DELETE_DOMAIN"
+      @webhookTokenPrivateDomain= "MAILINATOR_TEST_WEBHOOKTOKEN_PRIVATEDOMAIN"
+      @webhookTokenCustomService = "MAILINATOR_TEST_WEBHOOKTOKEN_CUSTOMSERVICE"
+      @authSecret = "MAILINATOR_TEST_AUTH_SECRET"
+      @authId = "MAILINATOR_TEST_AUTH_ID"
+      @webhookInbox = "MAILINATOR_TEST_WEBHOOK_INBOX"
+      @webhookCustomService = "MAILINATOR_TEST_WEBHOOK_CUSTOMSERVICE"
     end
 
     it "should correctly do manipulation with mailinator data" do
 
       client = MailinatorClient::Client.new(auth_token: @auth_token)
 
+      response = client.authenticators.instant_totp_2fa_code(totpSecretKey: @authSecret)
+      assert response != nil, "Expected instant totp 2fa code response to not be nil"
+      
+      response = client.authenticators.get_authenticators()
+      assert response != nil, "Expected get authenticators response to not be nil"
+      
+      response = client.authenticators.get_authenticators_by_id(id: @authId)
+      assert response != nil, "Expected get authenticators by id response to not be nil"
+      
+      response = client.authenticators.get_authenticator()
+      assert response != nil, "Expected get authenticator response to not be nil"
+      
+      response = client.authenticators.get_authenticator_by_id(id: @authId)
+      assert response != nil, "Expected get authenticator by id response to not be nil"
+
       response = client.domains.get_domains
       assert response != nil, "Expected get domains response to not be nil"
       assert response["domains"] != nil, "Expected response domains to not be nil"
@@ -24,13 +45,24 @@ class MailinatorClientApiTest < MiniTest::Test
       @domainId = @domain["_id"]
       @domainName = @domain["name"]
       
-      response = client.domains.get_domain(domainId:@domainId)
+      response = client.domains.get_domain(domainId:@domainName)
       assert response != nil, "Expected get domain response to not be nil"
 
+      @domainNameToAdd = "testruby.testinator.com"
+
+      response = client.domains.create_domain(domainId:@domainNameToAdd)
+      assert response != nil, "Expected create domain response to not be nil"
+      #assert response["status"] == "ok", "Expected create domain response to be ok"
+
+      response = client.domains.delete_domain(domainId:@domainNameToAdd)
+      assert response != nil, "Expected delete domain response to not be nil"
+      #assert response["status"] == "ok", "Expected delete domain response to be ok"
+      
+      random_string = SecureRandom.hex(4)
       ruleToPost = {
-        name:        "RuleName",
+        name:        "RuleName_RubyTest_#{random_string}",
         priority:    15,
-        description: "Description",
+        description: "Description_RubyTest_#{random_string}",
         conditions: [
           {
             operation: "PREFIX",
@@ -52,54 +84,94 @@ class MailinatorClientApiTest < MiniTest::Test
         ]
       }
 
-      response = client.rules.create_rule(domainId:@domainId, ruleToPost: ruleToPost)
+      response = client.rules.create_rule(domainId:@domainName, ruleToPost: ruleToPost)
       assert response != nil, "Expected get create rule response to not be nil"
       assert response["_id"] != nil, "Expected response rule id to not be nil"
 
-      response = client.rules.get_all_rules(domainId:@domainId)
+      response = client.rules.get_all_rules(domainId:@domainName)
       assert response != nil, "Expected get all rules response to not be nil"
       assert response["rules"] != nil, "Expected response rules to not be nil"
       @rule = response["rules"][0]
       @ruleId = @rule["_id"]
 
-      response = client.rules.enable_rule(domainId:@domainId, ruleId: @ruleId)
+      response = client.rules.enable_rule(domainId:@domainName, ruleId: @ruleId)
       assert response != nil, "Expected enable rule response to not be nil"
       assert response["status"] == "ok", "Expected enable rule response to be ok"
 
-      response = client.rules.disable_rule(domainId:@domainId, ruleId: @ruleId)
+      response = client.rules.disable_rule(domainId:@domainName, ruleId: @ruleId)
       assert response != nil, "Expected disable rule response to not be nil"
       assert response["status"] == "ok", "Expected disable rule response to be ok"
 
-      response = client.rules.get_rule(domainId:@domainId, ruleId: @ruleId)
+      response = client.rules.get_rule(domainId:@domainName, ruleId: @ruleId)
       assert response != nil, "Expected disable rule response to not be nil"
-      assert response["_id"] != nil, "Expected get rule response to not be nil"
+      assert response["_id"] != nil, "Expected get rule response id to not be nil"
 
       response = client.rules.delete_rule(domainId:@deleteDomain, ruleId: @ruleId)
       assert response != nil, "Expected delete rule response to not be nil"
       assert response["status"] == "ok", "Expected delete rule response to be ok"
 
+      messageToPost = {
+        subject:"Testing ruby message",
+        from:"test_email_ruby@test.com", 
+        text:"I love Ruby!"
+      }
+      response = client.messages.post_message(domain:@domainName, inbox: @inboxAll, messageToPost: messageToPost)
+      assert response != nil, "Expected post message response to not be nil"
+      assert response["status"] == "ok", "Expected post message response to be ok"
+
       response = client.messages.fetch_inbox(domain:@domainName, inbox: @inboxAll, skip: 0, limit: 50, sort: "ascending", decodeSubject: false)
       assert response != nil, "Expected fetch inbox response to not be nil"
       assert response["msgs"] != nil, "Expected response fetch inbox messages to not be nil"
       @message = response["msgs"][0]
       @messageId = @message["id"]
 
-      response = client.messages.fetch_message(domain:@domainName, inbox: @inboxAll, messageId: @messageId)
+      response = client.messages.fetch_inbox_message(domain:@domainName, inbox: @inboxAll, messageId: @messageId)
+      assert response != nil, "Expected fetch inbox message response to not be nil"
+
+      response = client.messages.fetch_message(domain:@domainName, messageId: @messageId)
       assert response != nil, "Expected fetch message response to not be nil"
 
-      response = client.messages.fetch_sms_message(domain:@domainName, inbox: @inboxAll, teamSmsNumber: @teamSMSNumber)
+      response = client.messages.fetch_sms_message(domain:@domainName, teamSmsNumber: @teamSMSNumber)
       assert response != nil, "Expected fetch sms message response to not be nil"
 
-      response = client.messages.fetch_attachments(domain:@domainName, inbox: @inbox, messageId: @messageIdWithAttachment)
-      assert response != nil, "Expected fetch attachments response to not be nil"
+      response = client.messages.fetch_inbox_message_attachments(domain:@domainName, inbox: @inbox, messageId: @messageIdWithAttachment)
+      assert response != nil, "Expected fetch inbox message attachments response to not be nil"
+
+      response = client.messages.fetch_message_attachments(domain:@domainName, messageId: @messageIdWithAttachment)
+      assert response != nil, "Expected fetch message attachments response to not be nil"
 
-      response = client.messages.fetch_attachment(domain:@domainName, inbox: @inbox, messageId: @messageIdWithAttachment, attachmentId: @attachmentId)
-      assert response != nil, "Expected fetch attachment response to not be nil"
+      response = client.messages.fetch_inbox_message_attachment(domain:@domainName, inbox: @inbox, messageId: @messageIdWithAttachment, attachmentId: @attachmentId)
+      assert response != nil, "Expected fetch inbox message attachment response to not be nil"
 
-      response = client.messages.fetch_message_links(domain:@domainName, inbox: @inboxAll, messageId: @messageId)
+      response = client.messages.fetch_message_attachment(domain:@domainName, messageId: @messageIdWithAttachment, attachmentId: @attachmentId)
+      assert response != nil, "Expected fetch message attachment response to not be nil"
+
+      response = client.messages.fetch_message_links(domain:@domainName, messageId: @messageId)
       assert response != nil, "Expected fetch message links response to not be nil"
       assert response["links"] != nil, "Expected fetch message links links response to not be nil"
+      
+      response = client.messages.fetch_inbox_message_links(domain:@domainName, inbox: @inboxAll, messageId: @messageId)
+      assert response != nil, "Expected fetch inbox message links response to not be nil"
+      assert response["links"] != nil, "Expected fetch inbox message links links response to not be nil"
 
+      response = client.messages.fetch_message_smtp_log(domain:@domainName, messageId: @messageId)
+      assert response != nil, "Expected fetch message smtp log response to not be nil"
+      
+      response = client.messages.fetch_inbox_message_smtp_log(domain:@domainName, inbox: @inboxAll, messageId: @messageId)
+      assert response != nil, "Expected fetch inbox message smtp log response to not be nil"
+      
+      response = client.messages.fetch_message_raw(domain:@domainName, messageId: @messageId)
+      assert response != nil, "Expected fetch message raw response to not be nil"
+      
+      response = client.messages.fetch_inbox_message_raw(domain:@domainName, inbox: @inboxAll, messageId: @messageId)
+      assert response != nil, "Expected fetch inbox message raw response to not be nil"
+      
+      response = client.messages.fetch_latest_messages(domain:@domainName)
+      assert response != nil, "Expected fetch latest messages response to not be nil"
+      
+      response = client.messages.fetch_latest_inbox_messages(domain:@domainName, inbox: @inboxAll)
+      assert response != nil, "Expected fetch latest inbox message response to not be nil"
+      
       response = client.messages.delete_message(domain:@deleteDomain, inbox: @inbox, messageId: @messageId)
       assert response != nil, "Expected delete message response to not be nil"
       assert response["status"] == "ok", "Expected delete message response to be ok"
@@ -112,21 +184,49 @@ class MailinatorClientApiTest < MiniTest::Test
       assert response != nil, "Expected delete all domain messages response to not be nil"
       assert response["status"] == "ok", "Expected delete all domain messages response to be ok"
 
-      messageToPost = {
-        subject:"Testing ruby message",
-        from:"test_email_ruby@test.com", 
-        text:"I love Ruby!"
-      }
-      response = client.messages.inject_message(domain:@domainName, inbox: @inboxAll, messageToPost: messageToPost)
-      assert response != nil, "Expected inject message response to not be nil"
-      assert response["status"] == "ok", "Expected inject message response to be ok"
-
       response = client.stats.get_team_stats
       assert response != nil, "Expected response to not be nil"
       assert response["stats"] != nil, "Expected response stats to not be nil"
 
       response = client.stats.get_team
       assert response != nil, "Expected response to not be nil"
+
+      webhook = {
+        from:"MyMailinatorRubyTest",
+        subject:"testing message",
+        text:"hello world",
+        to:"jack"
+      }
+
+      clientWithoutAuthToken = MailinatorClient::Client.new()
+      response = clientWithoutAuthToken.webhooks.public_webhook(webhook:webhook)
+      assert response != nil, "Expected public webhook response to not be nil"
+      assert response["status"] == "ok", "Expected public webhook response to be ok"
+      
+      response = clientWithoutAuthToken.webhooks.public_inbox_webhook(inbox: @webhookInbox, webhook:webhook)
+      assert response != nil, "Expected public inbox webhook response to not be nil"
+      assert response["status"] == "ok", "Expected public inbox webhook response to be ok"
+
+      response = clientWithoutAuthToken.webhooks.public_custom_service_webhook(customService: @webhookCustomService, webhook:webhook)
+      #assert response != nil, "Expected public custom service webhook response to not be nil"
+      
+      response = clientWithoutAuthToken.webhooks.public_custom_service_inbox_webhook(customService: @webhookCustomService, inbox: @webhookInbox, webhook:webhook)
+      #assert response != nil, "Expected public custom service inbox webhook response to not be nil"
+      
+      response = clientWithoutAuthToken.webhooks.private_webhook(whToken: @webhookTokenPrivateDomain, webhook:webhook)
+      assert response != nil, "Expected private webhook status response to not be nil"
+      assert response["status"] == "ok", "Expected private webhook response to be ok"
+
+      response = clientWithoutAuthToken.webhooks.private_inbox_webhook(whToken: @webhookTokenPrivateDomain, inbox: @webhookInbox, webhook:webhook)
+      assert response != nil, "Expected private inbox webhook response to not be nil"
+      assert response["status"] == "ok", "Expected private inbox webhook response to be ok"
+
+      response = clientWithoutAuthToken.webhooks.private_custom_service_webhook(whToken: @webhookTokenPrivateDomain, customService: @webhookCustomService, webhook:webhook)
+      #assert response != nil, "Expected private custom service webhook response to not be nil"
+      
+      response = clientWithoutAuthToken.webhooks.private_custom_service_inbox_webhook(whToken: @webhookTokenPrivateDomain, customService: @webhookCustomService, inbox: @webhookInbox, webhook:webhook)
+      #assert response != nil, "Expected private custom service inbox webhook response to not be nil"
+      
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mailinator_client
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.5
 platform: ruby
 authors:
 - Marian Melnychuk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-12 00:00:00.000000000 Z
+date: 2025-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -81,11 +81,14 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- docs/authenticators.md
 - docs/domains.md
 - docs/messages.md
 - docs/rules.md
 - docs/stats.md
+- docs/webhooks.md
 - lib/mailinator_client.rb
+- lib/mailinator_client/authenticators.rb
 - lib/mailinator_client/client.rb
 - lib/mailinator_client/domains.rb
 - lib/mailinator_client/error.rb
@@ -94,6 +97,7 @@ files:
 - lib/mailinator_client/stats.rb
 - lib/mailinator_client/utils.rb
 - lib/mailinator_client/version.rb
+- lib/mailinator_client/webhooks.rb
 - mailinator_client.gemspec
 - test/mailinator_client_api_test.rb
 - test/test_helper.rb
@@ -116,7 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: Provides a simple ruby wrapper around the Mailinator REST API