unione 1.1.3

data/lib/unione/api/email/model/message_object.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+module UniOne
+  module Api
+    module Email
+      module Model
+        # Object containing all message properties.
+        class MessageObject
+          # Contains recipient emails, substitutions(merge tags) and metadata.
+          # @return [Array<MessageObjectRecipientsItem>, nil]
+          attr_accessor :recipients
+
+          # Optional identifier of the template that had been created by
+          # [template/set](https://docs.unione.io/en/web-api-ref#template-set) method. If template_id is passed
+          # then fields from the template are used instead of missed email/send parameters. E.g. if "body"
+          # parameter in email/send is omitted, "body" from template will be used. If "subject" in email/send is
+          # omitted, "subject" from template will be used.
+          # @return [String, nil]
+          attr_accessor :template_id
+
+          # An array of strings. The maximum string length is 100 characters. You can include up to 4 strings
+          # which must be unique. No more than 10 000 tags are allowed per project; if you try to add more,
+          # email/send will return an error. You may use tags to categorize emails by your own criteria, and
+          # they will be passed along by event-dump methods.
+          # @return [Array<String>, nil]
+          attr_accessor :tags
+
+          # Whether to skip or not appending default unsubscribe footer. 1=skip, 0=append, default is 0. You
+          # should [ask support](https://cp.unione.io/en/support) to approve
+          # usage of skip_unsubscribe=1. [Read more](https://docs.unione.io/en/unsubscribe-link).
+          # Allowed values: `0`, `1`.
+          # @return [Integer, nil]
+          attr_accessor :skip_unsubscribe
+
+          # The language of the unsubscribe footer and unsubscribe page. Languages supported are: "be", "de",
+          # "en", "es", "fr", "it", "pl", "pt", "ru", "ua", "kz".
+          # @return [String, nil]
+          attr_accessor :global_language
+
+          # The [template engine](https://docs.unione.io/en/template-engines) for handling the
+          # substitutions(merge tags), "simple", "velocity", "liquid" or "none". Default value is "simple".
+          # @return [TemplateEngine, nil]
+          attr_accessor :template_engine
+
+          # Object for passing the substitutions(merge tags) common for all recipients - e.g., company name. If
+          # the substitution names are duplicated in object "substitutions", the values of the variables will be
+          # taken from the object "substitutions". The substitutions can be used in the following parameters:
+          #
+          # - body.html
+          # - body.plaintext
+          # - body.amp
+          # - subject
+          # - from_name
+          # - options.unsubscribe_url
+          # A substitution name can consist from latin characeters, numbers and "_" symbol, and should start
+          # with the letter.
+          # @return [Hash{String => String}, nil]
+          attr_accessor :global_substitutions
+
+          # Object for passing the metadata common for all the recipients, such as "key": "value". Max key
+          # quantity: 10. Max key length: 64 symbols. Max value length: 1024 symbols. The metadata is returned
+          # by [webhook](https://docs.unione.io/en/web-api-ref#webhook). To group single emails into a campaign,
+          # you can use the system key 'campaign_id' with a value in the form of a non-negative decimal integer
+          # up to 128 bits or a UUID in the format 'c7703772-453e-4c77-a9ae-9a1b94051b5a'. Incorrect values will
+          # be treated as '0'.
+          # @return [Hash{String => String}, nil]
+          attr_accessor :global_metadata
+
+          # Contains HTML/plaintext/AMP parts of the email. Either html or plaintext part is required.
+          # @return [BodyObject, nil]
+          attr_accessor :body
+
+          # Email subject.
+          # @return [String, nil]
+          attr_accessor :subject
+
+          # Sender's email. Required only if template_id parameter is empty.
+          # @return [String, nil]
+          attr_accessor :from_email
+
+          # Sender's name.
+          # @return [String, nil]
+          attr_accessor :from_name
+
+          # Optional Reply-To email (in case it's different to sender's email)
+          # @return [String, nil]
+          attr_accessor :reply_to
+
+          # Optional Reply-To name (if reply_to email is specified and you want to display not only this email
+          # but also the name)
+          # @return [String, nil]
+          attr_accessor :reply_to_name
+
+          # 1 = click tracking is on (default), 0 = click tracking is off. To use track_links = 0, you need to
+          # ask support to enable this feature.
+          # Allowed values: `0`, `1`.
+          # @return [Integer, nil]
+          attr_accessor :track_links
+
+          # 1 = read tracking is on (default), 0=read tracking is off. To use track_read = 0, you need to ask
+          # support to enable this feature.
+          # Allowed values: `0`, `1`.
+          # @return [Integer, nil]
+          attr_accessor :track_read
+
+          # (allowed values 0 or 1, default 0) If set to 1, the global unavailability list will be ignored. Even
+          # if the address was found to be unreachable while sending other UniOne users' emails, or its owner
+          # has issued complaints, the message will still be sent. The setting may be ignored for certain
+          # addresses.
+          # Allowed values: `0`, `1`.
+          # @return [Integer, nil]
+          attr_accessor :bypass_global
+
+          # (allowed values 0 or 1, default 0) If set to 1, the current user's or project's unavailability list
+          # will be ignored. Works only if bypass_global is set to 1.
+          # Allowed values: `0`, `1`.
+          # @return [Integer, nil]
+          attr_accessor :bypass_unavailable
+
+          # (allowed values 0 or 1, default 0) If set to 1, the current list of unsubscribed addresses for this
+          # account or project will be ignored. Works only if bypass_global is set to 1. The setting is
+          # available only for users that have been granted the right to omit the unsubscribe link (to request,
+          # please contact [support](https://cp.unione.io/en/support)).
+          # Allowed values: `0`, `1`.
+          # @return [Integer, nil]
+          attr_accessor :bypass_unsubscribed
+
+          # (allowed values 0 or 1, default 0) If set to 1, the user's or project's complaint list will be
+          # ignored. Works only if bypass_global is set to 1. The setting is available only for users that have
+          # been granted the right to omit the unsubscribe link (to request, please contact
+          # [support](https://cp.unione.io/en/support)).
+          # Allowed values: `0`, `1`.
+          # @return [Integer, nil]
+          attr_accessor :bypass_complained
+
+          # A string of up to 64 characters containing a unique message key. This can be used to prevent
+          # occasional message duplicates. If you send another API request with the same message key within the
+          # next minute, it will be declined. We can generate a message key for each letter automatically; to
+          # enable this option, please contact our [tech support](https://cp.unione.io/en/support).
+          # @return [String, nil]
+          attr_accessor :idempotence_key
+
+          # Contains email headers, maximum 50. Only headers with “X-” name prefix are accepted, all other are
+          # ignored, for example X-UNIONE-Global-Language, X-UNIONE-Template-Engine. Standard headers "To,"
+          # "CC," and "BCC" are passed without the "X-." Yet, they are processed in a particular way and, as a
+          # result, have a number of restrictions. You can find more details about it [here](/cc-and-bcc). If
+          # our support have approved omitting standard unsubscription block for you, you can also pass
+          # List-Unsubscribe, List-Subscribe, List-Help, List-Owner, List-Archive, In-Reply-To and References
+          # headers.
+          # @return [HeadersObject, nil]
+          attr_accessor :headers
+
+          # Optional array of attachments
+          # @return [Array<AttachmentsArrayItem>, nil]
+          attr_accessor :attachments
+
+          # Optional array of inline attachments, e.g. for including images in email instead of loading them
+          # from external URL.
+          # @return [Array<InlineAttachmentsArrayItem>, nil]
+          attr_accessor :inline_attachments
+
+          # Additional message options.
+          # @return [MessageObjectOptions, nil]
+          attr_accessor :options
+
+          def initialize(
+            recipients:,
+            body:,
+            subject:,
+            template_id: nil,
+            tags: nil,
+            skip_unsubscribe: nil,
+            global_language: nil,
+            template_engine: nil,
+            global_substitutions: nil,
+            global_metadata: nil,
+            from_email: nil,
+            from_name: nil,
+            reply_to: nil,
+            reply_to_name: nil,
+            track_links: nil,
+            track_read: nil,
+            bypass_global: nil,
+            bypass_unavailable: nil,
+            bypass_unsubscribed: nil,
+            bypass_complained: nil,
+            idempotence_key: nil,
+            headers: nil,
+            attachments: nil,
+            inline_attachments: nil,
+            options: nil
+          )
+            @recipients = recipients
+            @template_id = template_id
+            @tags = tags
+            @skip_unsubscribe = skip_unsubscribe
+            @global_language = global_language
+            @template_engine = template_engine
+            @global_substitutions = global_substitutions
+            @global_metadata = global_metadata
+            @body = body
+            @subject = subject
+            @from_email = from_email
+            @from_name = from_name
+            @reply_to = reply_to
+            @reply_to_name = reply_to_name
+            @track_links = track_links
+            @track_read = track_read
+            @bypass_global = bypass_global
+            @bypass_unavailable = bypass_unavailable
+            @bypass_unsubscribed = bypass_unsubscribed
+            @bypass_complained = bypass_complained
+            @idempotence_key = idempotence_key
+            @headers = headers
+            @attachments = attachments
+            @inline_attachments = inline_attachments
+            @options = options
+          end
+
+          # Builds the object from decoded JSON. Lenient: a missing field, nil or a value of another type
+          # gives nil (data that is not a Hash gives an empty object).
+          def self.from_h(data)
+            data = {} unless data.is_a?(Hash)
+            new(
+              recipients: ::UniOne::Client::Decode.list(data['recipients']) { |item0| ::UniOne::Client::Decode.model(::UniOne::Api::Email::Model::MessageObjectRecipientsItem, item0) },
+              body: ::UniOne::Client::Decode.model(::UniOne::Common::Model::BodyObject, data['body']),
+              subject: data['subject'],
+              template_id: data['template_id'],
+              tags: ::UniOne::Client::Decode.list(data['tags']),
+              skip_unsubscribe: data['skip_unsubscribe'],
+              global_language: data['global_language'],
+              template_engine: data['template_engine'],
+              global_substitutions: ::UniOne::Client::Decode.map(data['global_substitutions']),
+              global_metadata: ::UniOne::Client::Decode.map(data['global_metadata']),
+              from_email: data['from_email'],
+              from_name: data['from_name'],
+              reply_to: data['reply_to'],
+              reply_to_name: data['reply_to_name'],
+              track_links: data['track_links'],
+              track_read: data['track_read'],
+              bypass_global: data['bypass_global'],
+              bypass_unavailable: data['bypass_unavailable'],
+              bypass_unsubscribed: data['bypass_unsubscribed'],
+              bypass_complained: data['bypass_complained'],
+              idempotence_key: data['idempotence_key'],
+              headers: ::UniOne::Client::Decode.model(::UniOne::Common::Model::HeadersObject, data['headers']),
+              attachments: ::UniOne::Client::Decode.list(data['attachments']) { |item0| ::UniOne::Client::Decode.model(::UniOne::Common::Model::AttachmentsArrayItem, item0) },
+              inline_attachments: ::UniOne::Client::Decode.list(data['inline_attachments']) { |item0| ::UniOne::Client::Decode.model(::UniOne::Common::Model::InlineAttachmentsArrayItem, item0) },
+              options: ::UniOne::Client::Decode.model(::UniOne::Api::Email::Model::MessageObjectOptions, data['options'])
+            )
+          end
+
+          # JSON-ready hash, nil fields are omitted.
+          def to_h
+            {
+              'recipients' => @recipients.nil? ? nil : @recipients.map { |item0| item0.to_h },
+              'template_id' => @template_id,
+              'tags' => @tags,
+              'skip_unsubscribe' => @skip_unsubscribe,
+              'global_language' => @global_language,
+              'template_engine' => @template_engine,
+              'global_substitutions' => @global_substitutions,
+              'global_metadata' => @global_metadata,
+              'body' => @body.nil? ? nil : @body.to_h,
+              'subject' => @subject,
+              'from_email' => @from_email,
+              'from_name' => @from_name,
+              'reply_to' => @reply_to,
+              'reply_to_name' => @reply_to_name,
+              'track_links' => @track_links,
+              'track_read' => @track_read,
+              'bypass_global' => @bypass_global,
+              'bypass_unavailable' => @bypass_unavailable,
+              'bypass_unsubscribed' => @bypass_unsubscribed,
+              'bypass_complained' => @bypass_complained,
+              'idempotence_key' => @idempotence_key,
+              'headers' => @headers.nil? ? nil : @headers.to_h,
+              'attachments' => @attachments.nil? ? nil : @attachments.map { |item0| item0.to_h },
+              'inline_attachments' => @inline_attachments.nil? ? nil : @inline_attachments.map { |item0| item0.to_h },
+              'options' => @options.nil? ? nil : @options.to_h,
+            }.compact
+          end
+
+          def to_json(*args)
+            to_h.to_json(*args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/unione/api/email/model/message_object_options.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module UniOne
+  module Api
+    module Email
+      module Model
+        # Additional message options.
+        class MessageObjectOptions
+          # Date and time in "YYYY-MM-DD hh:mm:ss" format in the UTC timezone. Allows schedule sending up to 24
+          # hours in advance.
+          # @return [String, nil]
+          attr_accessor :send_at
+
+          # Custom unsubscribe link. Read more [here](https://docs.unione.io/en/unsubscribe-link).
+          # @return [String, nil]
+          attr_accessor :unsubscribe_url
+
+          # Backend-domain identifier to send message with. If custom_backend_id is not set, default one for
+          # your account/project will be used. You can pay for one or more dedicated IPs and use this option.
+          # @return [Integer, nil]
+          attr_accessor :custom_backend_id
+
+          # SMTP pool identifier to send message with. Usually you don't need to pass this parameter because
+          # correct smtp_pool_id is selected automatically based on the default one for your account/project or
+          # according to custom_backend_id parameter.
+          # @return [String, nil]
+          attr_accessor :smtp_pool_id
+
+          def initialize(
+            send_at: nil,
+            unsubscribe_url: nil,
+            custom_backend_id: nil,
+            smtp_pool_id: nil
+          )
+            @send_at = send_at
+            @unsubscribe_url = unsubscribe_url
+            @custom_backend_id = custom_backend_id
+            @smtp_pool_id = smtp_pool_id
+          end
+
+          # Builds the object from decoded JSON. Lenient: a missing field, nil or a value of another type
+          # gives nil (data that is not a Hash gives an empty object).
+          def self.from_h(data)
+            data = {} unless data.is_a?(Hash)
+            new(
+              send_at: data['send_at'],
+              unsubscribe_url: data['unsubscribe_url'],
+              custom_backend_id: data['custom_backend_id'],
+              smtp_pool_id: data['smtp_pool_id']
+            )
+          end
+
+          # JSON-ready hash, nil fields are omitted.
+          def to_h
+            {
+              'send_at' => @send_at,
+              'unsubscribe_url' => @unsubscribe_url,
+              'custom_backend_id' => @custom_backend_id,
+              'smtp_pool_id' => @smtp_pool_id,
+            }.compact
+          end
+
+          def to_json(*args)
+            to_h.to_json(*args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/unione/api/email/model/message_object_recipients_item.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module UniOne
+  module Api
+    module Email
+      module Model
+        # MessageObjectRecipientsItem
+        class MessageObjectRecipientsItem
+          # Recipient email
+          # @return [String, nil]
+          attr_accessor :email
+
+          # Object to pass the substitutions(merge tags) for the recipient (e.g. recipient name, discount code,
+          # password change link, etc. See [Template engines](https://docs.unione.io/en/template-engines)). The
+          # substitutions can be used in the following parameters:
+          #
+          # - body.html
+          # - body.plaintext
+          # - body.amp
+          # - subject
+          # - from_name
+          # - headers["List-Unsubscribe"]
+          # - options.unsubscribe_url
+          # A substitution name can consist from latin characters, numbers and "_" symbol, and should start with
+          # the letter. There's a special substitution "to_name" which is used to put recipent's name like "Name
+          # Surname" to include it to SMTP header "To" in the form "Name Surname <email@example.com>". The
+          # "to_name" length is limited to 78 symbols.
+          # @return [Hash{String => String}, nil]
+          attr_accessor :substitutions
+
+          # Object for passing the metadata, such as "key": "value". Max key quantity: 10. Max key length: 64
+          # symbols. Max value length: 1024 symbols. The metadata is returned by
+          # [webhook](https://docs.unione.io/en/web-api-ref#webhook) and
+          # [event-dump](https://docs.unione.io/en/web-api-ref#event-dump) methods. If you pass strign up to 128
+          # bit with "campaign_id" field name (name is configurable thru support), it will be considered as
+          # campaign identifier in statistics.
+          # @return [Hash{String => String}, nil]
+          attr_accessor :metadata
+
+          def initialize(
+            email:,
+            substitutions: nil,
+            metadata: nil
+          )
+            @email = email
+            @substitutions = substitutions
+            @metadata = metadata
+          end
+
+          # Builds the object from decoded JSON. Lenient: a missing field, nil or a value of another type
+          # gives nil (data that is not a Hash gives an empty object).
+          def self.from_h(data)
+            data = {} unless data.is_a?(Hash)
+            new(
+              email: data['email'],
+              substitutions: ::UniOne::Client::Decode.map(data['substitutions']),
+              metadata: ::UniOne::Client::Decode.map(data['metadata'])
+            )
+          end
+
+          # JSON-ready hash, nil fields are omitted.
+          def to_h
+            {
+              'email' => @email,
+              'substitutions' => @substitutions,
+              'metadata' => @metadata,
+            }.compact
+          end
+
+          def to_json(*args)
+            to_h.to_json(*args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/unione/api/email_validation/email_validation_api.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module UniOne
+  module Api
+    module EmailValidation
+      # Email validation methods. As a result of the check, you’ll get detailed information on email
+      # validity. It will help eliminate nonexistent emails, decrease the number of complaints, clean up the
+      # subscribers list and eventually enhance your sender reputation score. For example, you may add
+      # validation to a subscription form on your site to let users know they’ve just entered an invalid
+      # address.
+      class EmailValidationApi
+        # @param client [::UniOne::Client::ApiClient]
+        def initialize(client)
+          @client = client
+        end
+
+        # A maximum of two concurrent requests are allowed; if you send more requests, an error will be
+        # returned. Since the verification process should be completed promptly, we've set a time limit on
+        # email check. If we encounter a slow email server that does not respond in 5 seconds, you may get an
+        # “unknown” status.
+        #
+        # Documentation: https://docs.unione.io/en/web-api-ref#email-validation-single
+        # @param request [::UniOne::Api::EmailValidation::Model::EmailValidationSingleRequest, Hash]
+        # @return [::UniOne::Api::EmailValidation::Model::EmailValidationSingleResponse]
+        # @raise [::UniOne::Client::ApiError]
+        def single(request)
+          ::UniOne::Api::EmailValidation::Model::EmailValidationSingleResponse.from_h(@client.call('/email-validation/single.json', request.is_a?(Hash) ? request : request.to_h))
+        end
+      end
+    end
+  end
+end

data/lib/unione/api/email_validation/model/email_validation_single_request.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module UniOne
+  module Api
+    module EmailValidation
+      module Model
+        # EmailValidationSingleRequest
+        class EmailValidationSingleRequest
+          # Email address to be checked.
+          # @return [String, nil]
+          attr_accessor :email
+
+          def initialize(
+            email:
+          )
+            @email = email
+          end
+
+          # Builds the object from decoded JSON. Lenient: a missing field, nil or a value of another type
+          # gives nil (data that is not a Hash gives an empty object).
+          def self.from_h(data)
+            data = {} unless data.is_a?(Hash)
+            new(
+              email: data['email']
+            )
+          end
+
+          # JSON-ready hash, nil fields are omitted.
+          def to_h
+            {
+              'email' => @email,
+            }.compact
+          end
+
+          def to_json(*args)
+            to_h.to_json(*args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/unione/api/email_validation/model/email_validation_single_response.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module UniOne
+  module Api
+    module EmailValidation
+      module Model
+        # EmailValidationSingleResponse
+        class EmailValidationSingleResponse
+          # "success" string
+          # Allowed values: `success`.
+          # @return [String, nil]
+          attr_accessor :status
+
+          # Email address to be checked.
+          # @return [String, nil]
+          attr_accessor :email
+
+          # Possible statuses:
+          #
+          # - "valid" - the address is valid,
+          # - "invalid" - the address is invalid,
+          # - "suspicious" - the address looks suspicious,
+          # - "unknown" - could not perform validation, the domain’s mail server has not responded within the time limit.
+          # @return [String, nil]
+          attr_accessor :result
+
+          # Possible statuses:
+          #
+          # - "no_mx_record" - no MX record found for the target domain,
+          # - "syntax_error" - the address syntax is invalid,
+          # - "possible_typo" - the address is likely to have a typo,
+          # - "mailbox_not_found" - the address does not exist,
+          # - "global_suppression" - the address has been marked as unreachable due to multiple previous delivery errors,
+          # - "disposable" - this is a disposable one-time email address which is usually valid for a few minutes only,
+          # - "role" - the address is not likely to belong to an actual person, but rather to a certain business staff role,
+          # - "abuse" - the address is known to be a source of a large number of complaints, sometimes issued automatically,
+          # - "spamtrap" - this email is a spam trap, it is published openly but never used for actual emails. Sending messages to such addresses has a huge negative impact on reputation score,
+          # - "smtp_connection_failed" - the domain’s SMTP server does not respond; the address may contain a typo.
+          # @return [String, nil]
+          attr_accessor :cause
+
+          # Validity score, from 0 to 100 (0 – invalid, 100 – valid).
+          # @return [Integer, nil]
+          attr_accessor :validity
+
+          # Local part (everything preceding the @ sign).
+          # @return [String, nil]
+          attr_accessor :local_part
+
+          # Domain name part.
+          # @return [String, nil]
+          attr_accessor :domain
+
+          # True if the address’ domain does have an MX record, false if does not.
+          # @return [Boolean, nil]
+          attr_accessor :mx_found
+
+          # Preferred MX record for the domain.
+          # @return [String, nil]
+          attr_accessor :mx_record
+
+          # For addresses which are likely to have typing errors (cause=possible_typo), a suggested variant with
+          # a fixed typo.
+          # @return [String, nil]
+          attr_accessor :did_you_mean
+
+          # Email check date and time, YYYY-MM-DD hh:mm:ss UTC.
+          # @return [String, nil]
+          attr_accessor :processed_at
+
+          def initialize(
+            status: nil,
+            email: nil,
+            result: nil,
+            cause: nil,
+            validity: nil,
+            local_part: nil,
+            domain: nil,
+            mx_found: nil,
+            mx_record: nil,
+            did_you_mean: nil,
+            processed_at: nil
+          )
+            @status = status
+            @email = email
+            @result = result
+            @cause = cause
+            @validity = validity
+            @local_part = local_part
+            @domain = domain
+            @mx_found = mx_found
+            @mx_record = mx_record
+            @did_you_mean = did_you_mean
+            @processed_at = processed_at
+          end
+
+          # Builds the object from decoded JSON. Lenient: a missing field, nil or a value of another type
+          # gives nil (data that is not a Hash gives an empty object).
+          def self.from_h(data)
+            data = {} unless data.is_a?(Hash)
+            new(
+              status: data['status'],
+              email: data['email'],
+              result: data['result'],
+              cause: data['cause'],
+              validity: data['validity'],
+              local_part: data['local_part'],
+              domain: data['domain'],
+              mx_found: data['mx_found'],
+              mx_record: data['mx_record'],
+              did_you_mean: data['did_you_mean'],
+              processed_at: data['processed_at']
+            )
+          end
+
+          # JSON-ready hash, nil fields are omitted.
+          def to_h
+            {
+              'status' => @status,
+              'email' => @email,
+              'result' => @result,
+              'cause' => @cause,
+              'validity' => @validity,
+              'local_part' => @local_part,
+              'domain' => @domain,
+              'mx_found' => @mx_found,
+              'mx_record' => @mx_record,
+              'did_you_mean' => @did_you_mean,
+              'processed_at' => @processed_at,
+            }.compact
+          end
+
+          def to_json(*args)
+            to_h.to_json(*args)
+          end
+        end
+      end
+    end
+  end
+end