mailslurp_client 11.8.10 → 11.9.1

data/lib/mailslurp_client/models/download_attachment_dto.rb

@@ -15,13 +15,13 @@ require 'date'
 module MailSlurpClient
   # Content of attachment
   class DownloadAttachmentDto
-    # Base64 encoded string of attachment bytes. Decode the base64 string to get the raw file bytes
+    # Base64 encoded string of attachment bytes. Decode the base64 encoded string to get the raw contents. If the file has a content type such as `text/html` you can read the contents directly by converting it to string using `utf-8` encoding.
     attr_accessor :base64_file_contents
 
-    # Content type of attachment
+    # Content type of attachment. Examples are `image/png`, `application/msword`, `text/csv` etc.
     attr_accessor :content_type
 
-    # Size in bytes of attachment
+    # Size in bytes of attachment content
     attr_accessor :size_bytes
 
     # Attribute mapping from ruby-style variable name to JSON key.

data/lib/mailslurp_client/models/email.rb

@@ -13,7 +13,7 @@ OpenAPI Generator version: 4.3.1
 require 'date'
 
 module MailSlurpClient
-  # Email model (also referred to as EmailDto). Represents an email that was received by an inbox. If you want the original SMTP message see the `getRawEmail` endpoint.
+  # Email entity (also known as EmailDto). When an SMTP email message is received by MailSlurp it is parsed. The body and attachments are written to disk and the fields such as to, from, subject etc are stored in a database. The `body` contains the email content. If you want the original SMTP message see the `getRawEmail` endpoints. The attachments can be fetched using the AttachmentController
   class Email
     attr_accessor :analysis
 
@@ -41,21 +41,22 @@ module MailSlurpClient
     # Who the email was sent from
     attr_accessor :from
 
+    # Collection of SMTP headers attached to email
     attr_accessor :headers
 
-    # ID of the email
+    # ID of the email entity
     attr_accessor :id
 
     # ID of the inbox that received the email
     attr_accessor :inbox_id
 
-    # Was HTML sent in the email body
+    # Is the email body HTML
     attr_accessor :is_html
 
-    # Has the email been viewed ever. This means viewed in the dashboard or requested via the full email entity endpoints
+    # Read flag. Has the email ever been viewed in the dashboard or fetched via the API? If so the email is marked as read.
     attr_accessor :read
 
-    # The replyTo field on the received email
+    # The `replyTo` field on the received email message
     attr_accessor :reply_to
 
     # The subject line of the email message
@@ -64,13 +65,13 @@ module MailSlurpClient
     # Can the email be accessed by organization team members
     attr_accessor :team_access
 
-    # List of `To` recipients email was addressed to
+    # List of `To` recipients that email was addressed to
     attr_accessor :to
 
     # When was the email last updated
     attr_accessor :updated_at
 
-    # ID of user that email belongs
+    # ID of user that email belongs to
     attr_accessor :user_id
 
     # Attribute mapping from ruby-style variable name to JSON key.

data/lib/mailslurp_client/models/email_preview.rb

@@ -30,16 +30,16 @@ module MailSlurpClient
     # Who the email was sent from
     attr_accessor :from
 
-    # ID of the email
+    # ID of the email entity
     attr_accessor :id
 
-    # Has the email been viewed ever. This means viewed in the dashboard or requested via the full email entity endpoints
+    # Read flag. Has the email ever been viewed in the dashboard or fetched via the API? If so the email is marked as read.
     attr_accessor :read
 
     # The subject line of the email message
     attr_accessor :subject
 
-    # List of `To` recipients email was addressed to
+    # List of `To` recipients that email was addressed to
     attr_accessor :to
 
     # Attribute mapping from ruby-style variable name to JSON key.

data/lib/mailslurp_client/models/webhook_dto.rb

@@ -13,7 +13,7 @@ OpenAPI Generator version: 4.3.1
 require 'date'
 
 module MailSlurpClient
-  # Representation of a webhook for an inbox. The URL specified will be using by MailSlurp whenever an email is received by the attached inbox.
+  # Representation of a webhook for an inbox. The URL specified will be using by MailSlurp whenever an email is received by the attached inbox. A webhook entity should have a URL that points to your server. Your server should accept HTTP/S POST requests and return a success 200. MailSlurp will retry your webhooks if they fail. See https://api.mailslurp.com/schemas/webhook-payload for the payload schema.
   class WebhookDto
     # Does webhook expect basic authentication? If true it means you created this webhook with a username and password. MailSlurp will use these in the URL to authenticate itself.
     attr_accessor :basic_auth

data/lib/mailslurp_client/models/webhook_payload.rb

@@ -0,0 +1,370 @@
+=begin
+#MailSlurp API
+
+#MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.   ## Resources - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://www.mailslurp.com/docs/) - [Examples](https://github.com/mailslurp/examples) repository 
+
+The version of the OpenAPI document: 6.5.2
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 4.3.1
+
+=end
+
+require 'date'
+
+module MailSlurpClient
+  # MailSlurp webhook payload schema is available at https://api.mailslurp.com/schemas/webhook-payload. This schema describes the JSON object that is sent via HTTP POST to webhook urls when an email is received by an inbox that a webhook is attached to. Payloads may be delivered multiple times so use the ID as a key for event uniqueness. The payload contains IDs for the email and inbox affected. Use these to fetch more data related to the event using appropriate inbox and email endpoints. See https://www.mailslurp.com/guides/email-webhooks/ for more information. Your webhook endpoint should accept POST HTTP request and return a 200 in under 30 seconds. Process the webhook asynchronously if you need to.
+  class WebhookPayload
+    # List of attachment meta data objects if attachments present
+    attr_accessor :attachment_meta_datas
+
+    # List of `BCC` recipients email was addressed to
+    attr_accessor :bcc
+
+    # List of `CC` recipients email was addressed to
+    attr_accessor :cc
+
+    # Date time of event creation
+    attr_accessor :created_at
+
+    # ID of the email that was received. Use this ID for fetching the email
+    attr_accessor :email_id
+
+    # Name of the event type webhook is being triggered for
+    attr_accessor :event_name
+
+    # Who the email was sent from
+    attr_accessor :from
+
+    # Id of the inbox that receive an email
+    attr_accessor :inbox_id
+
+    # Idempotent message ID. Store this ID locally or in a database to prevent message duplication.
+    attr_accessor :message_id
+
+    # The subject line of the email message
+    attr_accessor :subject
+
+    # List of `To` recipients that email was addressed to
+    attr_accessor :to
+
+    # ID of webhook entity being triggered
+    attr_accessor :webhook_id
+
+    # Name of the webhook being triggered
+    attr_accessor :webhook_name
+
+    class EnumAttributeValidator
+      attr_reader :datatype
+      attr_reader :allowable_values
+
+      def initialize(datatype, allowable_values)
+        @allowable_values = allowable_values.map do |value|
+          case datatype.to_s
+          when /Integer/i
+            value.to_i
+          when /Float/i
+            value.to_f
+          else
+            value
+          end
+        end
+      end
+
+      def valid?(value)
+        !value || allowable_values.include?(value)
+      end
+    end
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'attachment_meta_datas' => :'attachmentMetaDatas',
+        :'bcc' => :'bcc',
+        :'cc' => :'cc',
+        :'created_at' => :'createdAt',
+        :'email_id' => :'emailId',
+        :'event_name' => :'eventName',
+        :'from' => :'from',
+        :'inbox_id' => :'inboxId',
+        :'message_id' => :'messageId',
+        :'subject' => :'subject',
+        :'to' => :'to',
+        :'webhook_id' => :'webhookId',
+        :'webhook_name' => :'webhookName'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'attachment_meta_datas' => :'Array<AttachmentMetaData>',
+        :'bcc' => :'Array<String>',
+        :'cc' => :'Array<String>',
+        :'created_at' => :'DateTime',
+        :'email_id' => :'String',
+        :'event_name' => :'String',
+        :'from' => :'String',
+        :'inbox_id' => :'String',
+        :'message_id' => :'String',
+        :'subject' => :'String',
+        :'to' => :'Array<String>',
+        :'webhook_id' => :'String',
+        :'webhook_name' => :'String'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `MailSlurpClient::WebhookPayload` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!self.class.attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `MailSlurpClient::WebhookPayload`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'attachment_meta_datas')
+        if (value = attributes[:'attachment_meta_datas']).is_a?(Array)
+          self.attachment_meta_datas = value
+        end
+      end
+
+      if attributes.key?(:'bcc')
+        if (value = attributes[:'bcc']).is_a?(Array)
+          self.bcc = value
+        end
+      end
+
+      if attributes.key?(:'cc')
+        if (value = attributes[:'cc']).is_a?(Array)
+          self.cc = value
+        end
+      end
+
+      if attributes.key?(:'created_at')
+        self.created_at = attributes[:'created_at']
+      end
+
+      if attributes.key?(:'email_id')
+        self.email_id = attributes[:'email_id']
+      end
+
+      if attributes.key?(:'event_name')
+        self.event_name = attributes[:'event_name']
+      end
+
+      if attributes.key?(:'from')
+        self.from = attributes[:'from']
+      end
+
+      if attributes.key?(:'inbox_id')
+        self.inbox_id = attributes[:'inbox_id']
+      end
+
+      if attributes.key?(:'message_id')
+        self.message_id = attributes[:'message_id']
+      end
+
+      if attributes.key?(:'subject')
+        self.subject = attributes[:'subject']
+      end
+
+      if attributes.key?(:'to')
+        if (value = attributes[:'to']).is_a?(Array)
+          self.to = value
+        end
+      end
+
+      if attributes.key?(:'webhook_id')
+        self.webhook_id = attributes[:'webhook_id']
+      end
+
+      if attributes.key?(:'webhook_name')
+        self.webhook_name = attributes[:'webhook_name']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      event_name_validator = EnumAttributeValidator.new('String', ["EMAIL_RECEIVED"])
+      return false unless event_name_validator.valid?(@event_name)
+      true
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] event_name Object to be assigned
+    def event_name=(event_name)
+      validator = EnumAttributeValidator.new('String', ["EMAIL_RECEIVED"])
+      unless validator.valid?(event_name)
+        fail ArgumentError, "invalid value for \"event_name\", must be one of #{validator.allowable_values}."
+      end
+      @event_name = event_name
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          attachment_meta_datas == o.attachment_meta_datas &&
+          bcc == o.bcc &&
+          cc == o.cc &&
+          created_at == o.created_at &&
+          email_id == o.email_id &&
+          event_name == o.event_name &&
+          from == o.from &&
+          inbox_id == o.inbox_id &&
+          message_id == o.message_id &&
+          subject == o.subject &&
+          to == o.to &&
+          webhook_id == o.webhook_id &&
+          webhook_name == o.webhook_name
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [attachment_meta_datas, bcc, cc, created_at, email_id, event_name, from, inbox_id, message_id, subject, to, webhook_id, webhook_name].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      new.build_from_hash(attributes)
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :Boolean
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        MailSlurpClient.const_get(type).build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+        
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end