customerio 5.6.0 → 6.1.0

data/lib/customerio/client.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "addressable/uri"
 
 module Customerio
@@ -8,21 +10,40 @@ module Customerio
   end
 
   class Client
-    PUSH_OPENED = 'opened'
-    PUSH_CONVERTED = 'converted'
-    PUSH_DELIVERED = 'delivered'
-
-    VALID_PUSH_EVENTS = [PUSH_OPENED, PUSH_CONVERTED, PUSH_DELIVERED]
-
-    class MissingIdAttributeError < RuntimeError; end
-    class ParamError < RuntimeError; end
+    DELIVERY_OPENED = "opened"
+    DELIVERY_CLICKED = "clicked"
+    DELIVERY_CONVERTED = "converted"
+    DELIVERY_DELIVERED = "delivered"
+    DELIVERY_BOUNCED = "bounced"
+    DELIVERY_DEFERRED = "deferred"
+    DELIVERY_DROPPED = "dropped"
+    DELIVERY_SPAMMED = "spammed"
+
+    VALID_DELIVERY_METRICS = [
+      DELIVERY_OPENED, DELIVERY_CLICKED, DELIVERY_CONVERTED,
+      DELIVERY_DELIVERED, DELIVERY_BOUNCED, DELIVERY_DEFERRED,
+      DELIVERY_DROPPED, DELIVERY_SPAMMED
+    ].freeze
+
+    VALID_PUSH_EVENTS = [DELIVERY_OPENED, DELIVERY_CONVERTED, DELIVERY_DELIVERED].freeze
+
+    # @deprecated Use DELIVERY_OPENED, DELIVERY_CONVERTED, DELIVERY_DELIVERED instead.
+    PUSH_OPENED = DELIVERY_OPENED
+    PUSH_CONVERTED = DELIVERY_CONVERTED
+    PUSH_DELIVERED = DELIVERY_DELIVERED
+
+    class MissingIdAttributeError < StandardError; end
+    class ParamError < StandardError; end
 
     def initialize(site_id, api_key, options = {})
-      options[:region] = Customerio::Regions::US if options[:region].nil?
-      raise "region must be an instance of Customerio::Regions::Region" unless options[:region].is_a?(Customerio::Regions::Region)
+      options = options.dup
+      options[:region] = Regions::US if options[:region].nil?
+      unless options[:region].is_a?(Regions::Region)
+        raise ArgumentError, "region must be an instance of Customerio::Regions::Region"
+      end
 
       options[:url] = options[:region].track_url if options[:url].nil? || options[:url].empty?
-      @client = Customerio::BaseClient.new({ site_id: site_id, api_key: api_key }, options)
+      @client = BaseClient.new({ site_id: site_id, api_key: api_key }, options)
     end
 
     def identify(attributes)
@@ -30,90 +51,122 @@ module Customerio
     end
 
     def delete(customer_id)
-      raise ParamError.new("customer_id must be a non-empty string") if is_empty?(customer_id)
+      raise ParamError, "customer_id must be a non-empty string" if empty?(customer_id)
+
       @client.request_and_verify_response(:delete, customer_path(customer_id))
     end
 
     def suppress(customer_id)
-      raise ParamError.new("customer_id must be a non-empty string") if is_empty?(customer_id)
+      raise ParamError, "customer_id must be a non-empty string" if empty?(customer_id)
+
       @client.request_and_verify_response(:post, suppress_path(customer_id))
     end
 
     def unsuppress(customer_id)
-      raise ParamError.new("customer_id must be a non-empty string") if is_empty?(customer_id)
+      raise ParamError, "customer_id must be a non-empty string" if empty?(customer_id)
+
       @client.request_and_verify_response(:post, unsuppress_path(customer_id))
     end
 
-    def track(customer_id, event_name, attributes = {})
-      raise ParamError.new("customer_id must be a non-empty string") if is_empty?(customer_id)
-      raise ParamError.new("event_name must be a non-empty string") if is_empty?(event_name)
+    def track(customer_id, event_name, attributes = {}, id: nil, timestamp: nil)
+      raise ParamError, "customer_id must be a non-empty string" if empty?(customer_id)
+      raise ParamError, "event_name must be a non-empty string" if empty?(event_name)
 
-      create_customer_event(customer_id, event_name, attributes)
+      create_customer_event(customer_id, event_name, attributes, id: id, timestamp: timestamp)
     end
 
     def pageview(customer_id, page, attributes = {})
-      raise ParamError.new("customer_id must be a non-empty string") if is_empty?(customer_id)
-      raise ParamError.new("page must be a non-empty string") if is_empty?(page)
+      raise ParamError, "customer_id must be a non-empty string" if empty?(customer_id)
+      raise ParamError, "page must be a non-empty string" if empty?(page)
 
       create_pageview_event(customer_id, page, attributes)
     end
 
-    def track_anonymous(anonymous_id, event_name, attributes = {})
-      raise ParamError.new("event_name must be a non-empty string") if is_empty?(event_name)
+    def track_anonymous(anonymous_id, event_name, attributes = {}, id: nil, timestamp: nil)
+      raise ParamError, "event_name must be a non-empty string" if empty?(event_name)
 
-      create_anonymous_event(anonymous_id, event_name, attributes)
+      create_anonymous_event(anonymous_id, event_name, attributes, id: id, timestamp: timestamp)
     end
 
-    def add_device(customer_id, device_id, platform, data={})
-      raise ParamError.new("customer_id must be a non-empty string") if is_empty?(customer_id)
-      raise ParamError.new("device_id must be a non-empty string") if is_empty?(device_id)
-      raise ParamError.new("platform must be a non-empty string") if is_empty?(platform)
+    def add_device(customer_id, device_id, platform, data = {})
+      raise ParamError, "customer_id must be a non-empty string" if empty?(customer_id)
+      raise ParamError, "device_id must be a non-empty string" if empty?(device_id)
+      raise ParamError, "platform must be a non-empty string" if empty?(platform)
 
-      if data.nil?
-        data = {}
-      end
+      data = {} if data.nil?
 
-      raise ParamError.new("data parameter must be a hash") unless data.is_a?(Hash)
+      raise ParamError, "data parameter must be a hash" unless data.is_a?(Hash)
 
-      @client.request_and_verify_response(:put, device_path(customer_id), {
-        :device => data.update({
-          :id => device_id,
-          :platform => platform,
-        })
-      })
+      @client.request_and_verify_response(
+        :put,
+        device_path(customer_id),
+        device: data.merge(id: device_id, platform: platform)
+      )
     end
 
     def delete_device(customer_id, device_id)
-      raise ParamError.new("customer_id must be a non-empty string") if is_empty?(customer_id)
-      raise ParamError.new("device_id must be a non-empty string") if is_empty?(device_id)
+      raise ParamError, "customer_id must be a non-empty string" if empty?(customer_id)
+      raise ParamError, "device_id must be a non-empty string" if empty?(device_id)
 
       @client.request_and_verify_response(:delete, device_id_path(customer_id, device_id))
     end
 
     def track_push_notification_event(event_name, attributes = {})
-        keys = [:delivery_id, :device_id, :timestamp]
-        attributes = Hash[attributes.map { |(k,v)| [ k.to_sym, v ] }].
-            select { |k, v| keys.include?(k) }
+      keys = %i[delivery_id device_id timestamp]
+      attributes = symbolize_keys(attributes).slice(*keys)
+
+      unless VALID_PUSH_EVENTS.include?(event_name)
+        raise ParamError, "event_name must be one of opened, converted, or delivered"
+      end
+
+      raise ParamError, "delivery_id must be a non-empty string" if empty?(attributes[:delivery_id])
+      raise ParamError, "device_id must be a non-empty string" if empty?(attributes[:device_id])
+      raise ParamError, "timestamp must be a valid timestamp" unless valid_timestamp?(attributes[:timestamp])
+
+      @client.request_and_verify_response(
+        :post,
+        track_push_notification_event_path,
+        attributes.merge(event: event_name)
+      )
+    end
 
-        raise ParamError.new('event_name must be one of opened, converted, or delivered') unless VALID_PUSH_EVENTS.include?(event_name)
-        raise ParamError.new('delivery_id must be a non-empty string') unless attributes[:delivery_id] != "" and !attributes[:delivery_id].nil?
-        raise ParamError.new('device_id must be a non-empty string') unless attributes[:device_id] != "" and !attributes[:device_id].nil?
-        raise ParamError.new('timestamp must be a valid timestamp') unless valid_timestamp?(attributes[:timestamp])
+    def track_delivery_metric(metric_name, attributes = {})
+      keys = %i[delivery_id timestamp recipient reason href]
+      attributes = symbolize_keys(attributes).slice(*keys)
+
+      unless VALID_DELIVERY_METRICS.include?(metric_name)
+        raise ParamError, "metric_name must be one of: #{VALID_DELIVERY_METRICS.join(', ')}"
+      end
+
+      raise ParamError, "delivery_id must be a non-empty string" if empty?(attributes[:delivery_id])
+
+      body = { delivery_id: attributes[:delivery_id], metric: metric_name }
+      validate_timestamp!(attributes[:timestamp])
+      body[:timestamp] = attributes[:timestamp] if valid_timestamp?(attributes[:timestamp])
+      body[:recipient] = attributes[:recipient] unless empty?(attributes[:recipient])
+      body[:reason] = attributes[:reason] unless empty?(attributes[:reason])
+      body[:href] = attributes[:href] unless empty?(attributes[:href])
 
-        @client.request_and_verify_response(:post, track_push_notification_event_path, attributes.merge(event: event_name))
+      @client.request_and_verify_response(:post, delivery_metrics_path, body)
     end
 
     def merge_customers(primary_id_type, primary_id, secondary_id_type, secondary_id)
-      raise ParamError.new("invalid primary_id_type") if !is_valid_id_type?(primary_id_type)
-      raise ParamError.new("primary_id must be a non-empty string") if is_empty?(primary_id)
-      raise ParamError.new("invalid secondary_id_type") if !is_valid_id_type?(secondary_id_type)
-      raise ParamError.new("secondary_id must be a non-empty string") if is_empty?(secondary_id)
+      raise ParamError, "invalid primary_id_type" unless valid_id_type?(primary_id_type)
+      raise ParamError, "primary_id must be a non-empty string" if empty?(primary_id)
+      raise ParamError, "invalid secondary_id_type" unless valid_id_type?(secondary_id_type)
+      raise ParamError, "secondary_id must be a non-empty string" if empty?(secondary_id)
 
-      body = { :primary => {primary_id_type => primary_id}, :secondary => {secondary_id_type => secondary_id} }
+      body = { primary: { primary_id_type => primary_id }, secondary: { secondary_id_type => secondary_id } }
 
       @client.request_and_verify_response(:post, merge_customers_path, body)
     end
 
+    def batch(operations)
+      raise ParamError, "operations must be a non-empty array" unless operations.is_a?(Array) && !operations.empty?
+
+      @client.request_and_verify_response(:post, batch_path, batch: operations)
+    end
+
     private
 
     def escape(val)
@@ -142,17 +195,25 @@ module Customerio
     end
 
     def track_push_notification_event_path
-        "/push/events"
+      "/push/events"
+    end
+
+    def delivery_metrics_path
+      "/api/v1/metrics"
     end
 
     def merge_customers_path
       "/api/v1/merge_customers"
     end
 
+    def batch_path
+      "/api/v2/batch"
+    end
+
     def create_or_update(attributes = {})
-      attributes = Hash[attributes.map { |(k,v)| [ k.to_sym, v ] }]
-      if is_empty?(attributes[:id]) && is_empty?(attributes[:cio_id]) && is_empty?(attributes[:customer_id])
-        raise MissingIdAttributeError.new("Must provide a customer id")
+      attributes = symbolize_keys(attributes)
+      if empty?(attributes[:id]) && empty?(attributes[:cio_id]) && empty?(attributes[:customer_id])
+        raise MissingIdAttributeError, "Must provide a customer id"
       end
 
       # Use cio_id as the identifier, if present,
@@ -169,12 +230,9 @@ module Customerio
       #
       # 3. id: The id value.
       customer_id = attributes[:id]
-      if !is_empty?(attributes[:cio_id])
-        customer_id = "cio_" + attributes[:cio_id]
-      end
-      if !is_empty?(attributes[:customer_id])
-        customer_id = attributes[:customer_id]
-      end
+      customer_id = "cio_#{attributes[:cio_id]}" unless empty?(attributes[:cio_id])
+      customer_id = attributes[:customer_id] unless empty?(attributes[:customer_id])
+
       # customer_id is not an attribute, so remove it.
       attributes.delete(:customer_id)
 
@@ -182,20 +240,24 @@ module Customerio
       @client.request_and_verify_response(:put, url, attributes)
     end
 
-    def create_customer_event(customer_id, event_name, attributes = {})
+    def create_customer_event(customer_id, event_name, attributes = {}, id: nil, timestamp: nil)
       create_event(
         url: "#{customer_path(customer_id)}/events",
         event_name: event_name,
-        attributes: attributes
+        attributes: attributes,
+        id: id,
+        timestamp: timestamp
       )
     end
 
-    def create_anonymous_event(anonymous_id, event_name, attributes = {})
+    def create_anonymous_event(anonymous_id, event_name, attributes = {}, id: nil, timestamp: nil)
       create_event(
         url: "/api/v1/events",
         event_name: event_name,
         anonymous_id: anonymous_id,
-        attributes: attributes
+        attributes: attributes,
+        id: id,
+        timestamp: timestamp
       )
     end
 
@@ -208,25 +270,41 @@ module Customerio
       )
     end
 
-    def create_event(url:, event_name:, anonymous_id: nil, event_type: nil, attributes: {})
-      body = { :name => event_name, :data => attributes }
-      body[:timestamp] = attributes[:timestamp] if valid_timestamp?(attributes[:timestamp])
-      body[:anonymous_id] = anonymous_id unless is_empty?(anonymous_id)
-      body[:type] = event_type unless is_empty?(event_type)
+    def create_event(url:, event_name:, anonymous_id: nil, event_type: nil, attributes: {}, id: nil, timestamp: nil) # rubocop:disable Metrics/ParameterLists
+      body = { name: event_name, data: attributes }
+      effective_timestamp = timestamp || attributes[:timestamp]
+      if effective_timestamp
+        validate_timestamp!(effective_timestamp)
+        body[:timestamp] = effective_timestamp
+      end
+      body[:anonymous_id] = anonymous_id unless empty?(anonymous_id)
+      body[:type] = event_type unless empty?(event_type)
+      body[:id] = id unless empty?(id)
 
       @client.request_and_verify_response(:post, url, body)
     end
 
     def valid_timestamp?(timestamp)
-      timestamp && timestamp.is_a?(Integer) && timestamp > 999999999 && timestamp < 100000000000
+      timestamp.is_a?(Integer) && timestamp > 999_999_999 && timestamp < 100_000_000_000
     end
 
-    def is_empty?(val)
-      val.nil? || (val.is_a?(String) && val.strip == "")
+    def validate_timestamp!(timestamp)
+      return if timestamp.nil?
+      return if valid_timestamp?(timestamp)
+
+      raise ParamError, "timestamp must be a valid integer (seconds since epoch, 10-digit range)"
     end
 
-    def is_valid_id_type?(input)
+    def empty?(val)
+      val.nil? || (val.is_a?(String) && val.strip.empty?)
+    end
+
+    def valid_id_type?(input)
       [IdentifierType::ID, IdentifierType::CIOID, IdentifierType::EMAIL].include? input
     end
+
+    def symbolize_keys(hash)
+      hash.transform_keys(&:to_sym)
+    end
   end
 end

data/lib/customerio/regions.rb

@@ -1,11 +1,10 @@
-require 'net/http'
-require 'multi_json'
+# frozen_string_literal: true
 
 module Customerio
   module Regions
     Region = Struct.new(:track_url, :api_url)
 
-    US = Customerio::Regions::Region.new('https://track.customer.io', 'https://api.customer.io').freeze
-    EU = Customerio::Regions::Region.new('https://track-eu.customer.io', 'https://api-eu.customer.io').freeze
+    US = Region.new("https://track.customer.io", "https://api.customer.io").freeze
+    EU = Region.new("https://track-eu.customer.io", "https://api-eu.customer.io").freeze
   end
 end

data/lib/customerio/requests/send_email_request.rb

@@ -1,25 +1,12 @@
-require 'base64'
+# frozen_string_literal: true
+
+require "base64"
 
 module Customerio
   class SendEmailRequest
-    attr_reader :message
-
-    def initialize(opts)
-      @message = opts.delete_if { |field| invalid_field?(field) }
-      @message[:attachments] = {}
-      @message[:headers] = {}
-    end
-
-    def attach(name, data, encode: true)
-      raise "attachment #{name} already exists" if @message[:attachments].has_key?(name)
-      @message[:attachments][name] = encode ? Base64.strict_encode64(data) : data
-    end
-
-    private
+    REQUIRED_FIELDS = %i[to identifiers].freeze
 
-    REQUIRED_FIELDS = %i(to identifiers)
-
-    OPTIONAL_FIELDS = %i(
+    OPTIONAL_FIELDS = %i[
       transactional_message_id
       message_data
       headers
@@ -39,14 +26,26 @@ module Customerio
       disable_css_preprocessing
       send_at
       language
-    )
+    ].freeze
+
+    attr_reader :message
 
-    def invalid_field?(field)
-      !REQUIRED_FIELDS.include?(field) && !OPTIONAL_FIELDS.include?(field)
+    def initialize(opts)
+      @message = opts.select { |field, _value| valid_field?(field) }
+      @message[:attachments] ||= {}
+      @message[:headers] ||= {}
     end
 
-    def encode(data)
-      Base64.strict_encode64(data)
+    def attach(name, data, encode: true)
+      raise ArgumentError, "attachment #{name} already exists" if @message[:attachments].key?(name)
+
+      @message[:attachments][name] = encode ? Base64.strict_encode64(data) : data
+    end
+
+    private
+
+    def valid_field?(field)
+      REQUIRED_FIELDS.include?(field) || OPTIONAL_FIELDS.include?(field)
     end
   end
 end

data/lib/customerio/requests/send_in_app_request.rb

@@ -1,31 +1,27 @@
-require 'base64'
+# frozen_string_literal: true
 
 module Customerio
   class SendInAppRequest
-    attr_reader :message
-
-    def initialize(opts)
-      @message = opts.delete_if { |field| invalid_field?(field) }
-    end
-
-    private
+    REQUIRED_FIELDS = %i[identifiers transactional_message_id].freeze
 
-    REQUIRED_FIELDS = %i(identifiers transactional_message_id)
-
-    OPTIONAL_FIELDS = %i(
+    OPTIONAL_FIELDS = %i[
       message_data
       disable_message_retention
       queue_draft
       send_at
       language
-    )
+    ].freeze
+
+    attr_reader :message
 
-    def invalid_field?(field)
-      !REQUIRED_FIELDS.include?(field) && !OPTIONAL_FIELDS.include?(field)
+    def initialize(opts)
+      @message = opts.select { |field, _value| valid_field?(field) }
     end
 
-    def encode(data)
-      Base64.strict_encode64(data)
+    private
+
+    def valid_field?(field)
+      REQUIRED_FIELDS.include?(field) || OPTIONAL_FIELDS.include?(field)
     end
   end
 end

data/lib/customerio/requests/send_inbox_message_request.rb

@@ -1,31 +1,27 @@
-require 'base64'
+# frozen_string_literal: true
 
 module Customerio
   class SendInboxMessageRequest
-    attr_reader :message
-
-    def initialize(opts)
-      @message = opts.delete_if { |field| invalid_field?(field) }
-    end
-
-    private
+    REQUIRED_FIELDS = %i[identifiers transactional_message_id].freeze
 
-    REQUIRED_FIELDS = %i(identifiers transactional_message_id)
-
-    OPTIONAL_FIELDS = %i(
+    OPTIONAL_FIELDS = %i[
       message_data
       disable_message_retention
       queue_draft
       send_at
       language
-    )
+    ].freeze
+
+    attr_reader :message
 
-    def invalid_field?(field)
-      !REQUIRED_FIELDS.include?(field) && !OPTIONAL_FIELDS.include?(field)
+    def initialize(opts)
+      @message = opts.select { |field, _value| valid_field?(field) }
     end
 
-    def encode(data)
-      Base64.strict_encode64(data)
+    private
+
+    def valid_field?(field)
+      REQUIRED_FIELDS.include?(field) || OPTIONAL_FIELDS.include?(field)
     end
   end
 end

data/lib/customerio/requests/send_push_request.rb

@@ -1,17 +1,10 @@
+# frozen_string_literal: true
+
 module Customerio
   class SendPushRequest
-    attr_reader :message
-
-    def initialize(opts)
-      @message = opts.delete_if { |field| invalid_field?(field) }
-      @message[:custom_device] = opts[:device] if opts[:device]
-    end
-
-    private
-
-    REQUIRED_FIELDS = %i(transactional_message_id identifiers)
+    REQUIRED_FIELDS = %i[transactional_message_id identifiers].freeze
 
-    OPTIONAL_FIELDS = %i(
+    OPTIONAL_FIELDS = %i[
       to
       title
       message
@@ -25,12 +18,20 @@ module Customerio
       link
       sound
       custom_data
-      device
       custom_device
-    )
+    ].freeze
+
+    attr_reader :message
+
+    def initialize(opts)
+      @message = opts.select { |field, _value| valid_field?(field) }
+      @message[:custom_device] = opts[:device] if opts[:device]
+    end
+
+    private
 
-    def invalid_field?(field)
-      !REQUIRED_FIELDS.include?(field) && !OPTIONAL_FIELDS.include?(field)
+    def valid_field?(field)
+      REQUIRED_FIELDS.include?(field) || OPTIONAL_FIELDS.include?(field)
     end
   end
 end

data/lib/customerio/requests/send_sms_request.rb

@@ -1,25 +1,12 @@
-require 'base64'
+# frozen_string_literal: true
+
+require "base64"
 
 module Customerio
   class SendSMSRequest
-    attr_reader :message
-
-    def initialize(opts)
-      @message = opts.delete_if { |field| invalid_field?(field) }
-      @message[:attachments] = {}
-      @message[:headers] = {}
-    end
-
-    def attach(name, data, encode: true)
-      raise "attachment #{name} already exists" if @message[:attachments].has_key?(name)
-      @message[:attachments][name] = encode ? Base64.strict_encode64(data) : data
-    end
-
-    private
+    REQUIRED_FIELDS = %i[identifiers transactional_message_id].freeze
 
-    REQUIRED_FIELDS = %i(identifiers transactional_message_id)
-
-    OPTIONAL_FIELDS = %i(
+    OPTIONAL_FIELDS = %i[
       message_data
       from
       to
@@ -29,14 +16,25 @@ module Customerio
       queue_draft
       send_at
       language
-    )
+    ].freeze
+
+    attr_reader :message
 
-    def invalid_field?(field)
-      !REQUIRED_FIELDS.include?(field) && !OPTIONAL_FIELDS.include?(field)
+    def initialize(opts)
+      @message = opts.select { |field, _value| valid_field?(field) }
+      @message[:attachments] ||= {}
     end
 
-    def encode(data)
-      Base64.strict_encode64(data)
+    def attach(name, data, encode: true)
+      raise ArgumentError, "attachment #{name} already exists" if @message[:attachments].key?(name)
+
+      @message[:attachments][name] = encode ? Base64.strict_encode64(data) : data
+    end
+
+    private
+
+    def valid_field?(field)
+      REQUIRED_FIELDS.include?(field) || OPTIONAL_FIELDS.include?(field)
     end
   end
 end

data/lib/customerio/requests/trigger_broadcast_request.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Customerio
+  class TriggerBroadcastRequest
+    AUDIENCE_FIELDS = %i[recipients emails ids per_user_data data_file_url].freeze
+
+    OPTIONAL_FIELDS = %i[data email_add_duplicates email_ignore_missing id_ignore_missing].freeze
+
+    attr_reader :broadcast_id, :message
+
+    def initialize(opts)
+      raise ArgumentError, "broadcast_id is required" unless opts.key?(:broadcast_id)
+      raise ArgumentError, "broadcast_id must be an integer" unless opts[:broadcast_id].is_a?(Integer)
+
+      @broadcast_id = opts[:broadcast_id]
+      @message = opts.select { |field, _value| valid_field?(field) }
+
+      audience = AUDIENCE_FIELDS.select { |field| @message.key?(field) }
+      raise ArgumentError, "only one of #{AUDIENCE_FIELDS.join(', ')} can be present" if audience.length > 1
+    end
+
+    private
+
+    def valid_field?(field)
+      OPTIONAL_FIELDS.include?(field) || AUDIENCE_FIELDS.include?(field)
+    end
+  end
+end

data/lib/customerio/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Customerio
-  VERSION = "5.6.0"
+  VERSION = "6.1.0"
 end