mailerlite-ruby 2.0.0 → 2.1.0

data/lib/mailerlite/automations/automations.rb

@@ -14,17 +14,21 @@ module MailerLite
 
     # Returns a list of Automations that match the specified filter criteria.
     #
-    # @param filter[:status,:name,:group] [Array] filters for automation
+    # @param filter[:status,:name,:group,:folder,:enabled,:automation_state,:drafts_state] [Array] filters for automation
     # @param limit [Integer] the maximum number of Automations to return
     # @param page [Integer] the page number of the results to return
+    # @param sort [String] the field to sort by, prefix with - for descending order
+    # @param with_steps [Boolean] include the steps of each Automation, defaults to true
     # @return [HTTP::Response] the response from the API
-    def get(limit: nil, page: nil, filter: {})
+    def get(limit: nil, page: nil, filter: {}, sort: nil, with_steps: nil)
       params = {}
-      params['filter[status]'] = filter[:status] if filter.key?(:status)
-      params['filter[name]'] = filter[:name] if filter.key?(:name)
-      params['filter[group]'] = filter[:group] if filter.key?(:group)
+      %i[status name group folder enabled automation_state drafts_state].each do |key|
+        params["filter[#{key}]"] = filter[key] if filter.key?(key)
+      end
       params['limit'] = limit if limit
       params['page'] = page if page
+      params['sort'] = sort if sort
+      params['with_steps'] = QueryParams.boolean(with_steps)
       uri = URI("#{MAILERLITE_API_URL}/automations")
       uri.query = URI.encode_www_form(params.compact)
       client.http.get(uri)
@@ -38,25 +42,190 @@ module MailerLite
       client.http.get("#{MAILERLITE_API_URL}/automations/#{automation_id}")
     end
 
+    # Creates an Automation
+    #
+    # @param name [String] the name of the Automation
+    # @return [HTTP::Response] the response from the API
+    def create(name:)
+      client.http.post("#{MAILERLITE_API_URL}/automations", json: { 'name' => name })
+    end
+
+    # Updates the specified Automation
+    #
+    # @param automation_id [String] the ID of the Automation to update
+    # @param name [String] the name of the Automation
+    # @param trigger_data [Hash] the settings of the first trigger
+    # @param triggers [Array] the triggers of the Automation
+    # @return [HTTP::Response] the response from the API
+    def update(automation_id:, name:, trigger_data: nil, triggers: nil)
+      params = { 'name' => name, 'trigger_data' => trigger_data, 'triggers' => triggers }
+      client.http.put("#{MAILERLITE_API_URL}/automations/#{automation_id}", json: params.compact)
+    end
+
+    # Deletes the specified Automation
+    #
+    # @param automation_id [String] the ID of the Automation to delete
+    # @return [HTTP::Response] the response from the API
+    def delete(automation_id)
+      client.http.delete("#{MAILERLITE_API_URL}/automations/#{automation_id}")
+    end
+
+    # Copies the specified Automation
+    #
+    # @param automation_id [String] the ID of the Automation to copy
+    # @return [HTTP::Response] the response from the API
+    def copy(automation_id)
+      client.http.post("#{MAILERLITE_API_URL}/automations/#{automation_id}/copy")
+    end
+
+    # Enables the specified Automation
+    #
+    # @param automation_id [String] the ID of the Automation to enable
+    # @return [HTTP::Response] the response from the API
+    def enable(automation_id)
+      client.http.post("#{MAILERLITE_API_URL}/automations/#{automation_id}/enable")
+    end
+
+    # Disables the specified Automation
+    #
+    # @param automation_id [String] the ID of the Automation to disable
+    # @return [HTTP::Response] the response from the API
+    def disable(automation_id)
+      client.http.post("#{MAILERLITE_API_URL}/automations/#{automation_id}/disable")
+    end
+
+    # Sends the emails of the specified Automation to a test address
+    #
+    # @param automation_id [String] the ID of the Automation to test
+    # @param email [String] the address to send the test emails to
+    # @return [HTTP::Response] the response from the API
+    def test(automation_id:, email:)
+      client.http.post("#{MAILERLITE_API_URL}/automations/#{automation_id}/test", json: { 'email' => email })
+    end
+
+    # Adds subscribers to the specified Automation
+    #
+    # @param automation_id [String] the ID of the Automation
+    # @param step_id [Integer] the step to start the subscribers at
+    # @param emails [Array] the email addresses of the subscribers to add
+    # @param groups [Array] the IDs of the groups whose subscribers to add
+    # @return [HTTP::Response] the response from the API
+    def add_subscribers(automation_id:, step_id: nil, emails: nil, groups: nil)
+      params = { 'step_id' => step_id, 'emails' => emails, 'groups' => groups }
+      client.http.post("#{MAILERLITE_API_URL}/automations/#{automation_id}/add-subscribers", json: params.compact)
+    end
+
+    # Adds subscribers back to the specified Automation
+    #
+    # @param automation_id [String] the ID of the Automation
+    # @param readd_subscribers_to [String] last_completed_step, selected_step or last_failed_step
+    # @param filter [Hash] the activity to re-add, with status and optional search, date_from, date_to, id and step
+    # @param selected_step_id [String] the step to re-add the subscribers to, when readd_subscribers_to is selected_step
+    # @return [HTTP::Response] the response from the API
+    def readd(automation_id:, readd_subscribers_to:, filter:, selected_step_id: nil)
+      params = { 'readd_subscribers_to' => readd_subscribers_to, 'filter' => filter, 'selected_step_id' => selected_step_id }
+      client.http.post("#{MAILERLITE_API_URL}/automations/#{automation_id}/readd", json: params.compact)
+    end
+
+    # Adds the subscribers in the activity of the specified Automation to groups
+    #
+    # @param automation_id [String] the ID of the Automation
+    # @param destination_groups [Array] the IDs of the groups to add the subscribers to
+    # @param filter [Hash] the activity to act on, with status and optional id, search and date filters
+    # @return [HTTP::Response] the response from the API
+    def add_activity_to_group(automation_id:, destination_groups:, filter:)
+      params = { 'destination_groups' => destination_groups, 'filter' => filter }
+      client.http.post("#{MAILERLITE_API_URL}/automations/#{automation_id}/activity/add-to-group", json: params)
+    end
+
+    # Cancels the active runs in the activity of the specified Automation
+    #
+    # @param automation_id [String] the ID of the Automation
+    # @param filter [Hash] the activity to act on, with status active and optional id, search and date filters
+    # @return [HTTP::Response] the response from the API
+    def cancel_activity(automation_id:, filter:)
+      client.http.post("#{MAILERLITE_API_URL}/automations/#{automation_id}/activity/cancel-automation", json: { 'filter' => filter })
+    end
+
+    # Skips the current delay of the active runs in the activity of the specified Automation
+    #
+    # @param automation_id [String] the ID of the Automation
+    # @param filter [Hash] the activity to act on, with status active and optional id, search and date filters
+    # @return [HTTP::Response] the response from the API
+    def skip_activity_delay(automation_id:, filter:)
+      client.http.post("#{MAILERLITE_API_URL}/automations/#{automation_id}/activity/skip-delay", json: { 'filter' => filter })
+    end
+
     # get_subscriber_activity the subscriber activity for specified Automation
     #
     # @param automation_id [Integer] the ID of the Automation to get_subscriber_activity
-    # @param filter[:status,:date_from,:date_to,:scheduled_from,:scheduled_to,:keyword] [Array] Must be one of the following: completed, active, canceled, failed
+    # @param filter[:status,:date_from,:date_to,:scheduled_from,:scheduled_to,:search] [Array] Must be one of the following: completed, active, canceled, failed
+    # @param filter[:keyword] [String] deprecated, sent as filter[search], use filter[:search]
     # @param limit [Integer] the maximum number of Automations to return
     # @param page [Integer] the page number of the results to return
+    # @param sort [String] the field to sort by, prefix with - for descending order
+    # @param with_subscribers [Boolean] include the id, email and name of each subscriber
     # @return [HTTP::Response] the response from the API
-    def get_subscriber_activity(automation_id:, filter: {}, page: nil, limit: nil)
+    def get_subscriber_activity(automation_id:, filter: {}, page: nil, limit: nil, sort: nil, with_subscribers: nil)
       params = { 'filter[status]' => filter[:status] }
       params['filter[date_from]'] = filter[:date_from] if filter.key?(:date_from)
       params['filter[date_to]'] = filter[:date_to] if filter.key?(:date_to)
       params['filter[scheduled_from]'] = filter[:scheduled_from] if filter.key?(:scheduled_from)
       params['filter[scheduled_to]'] = filter[:scheduled_to] if filter.key?(:scheduled_to)
-      params['filter[keyword]'] = filter[:keyword] if filter.key?(:keyword)
+      params['filter[search]'] = filter.fetch(:search, filter[:keyword])
       params['page'] = page if page
       params['limit'] = limit if limit
+      params['sort'] = sort if sort
+      params['with_subscribers'] = 1 if with_subscribers
       uri = URI("#{MAILERLITE_API_URL}/automations/#{automation_id}/activity")
       uri.query = URI.encode_www_form(params.compact)
       client.http.get(uri)
     end
+
+    # Returns the orders and revenue an automation earned
+    #
+    # @param automation_id [String] the ID of the Automation
+    # @param shop_id [String] report on one shop only
+    # @param start_date [String] the first day, together with end_date
+    # @param end_date [String] the last day, included
+    # @return [HTTP::Response] the response from the API
+    def ecommerce_stats(automation_id:, shop_id: nil, start_date: nil, end_date: nil)
+      uri = URI("#{MAILERLITE_API_URL}/automations/#{automation_id}/monthly-totals/ecommerce")
+      query = { 'shop_id' => shop_id, 'start_date' => start_date, 'end_date' => end_date }.compact
+      uri.query = URI.encode_www_form(query) unless query.empty?
+      client.http.get(uri)
+    end
+
+    # Returns the orders and revenue one automation email earned
+    #
+    # @param automation_id [String] the ID of the Automation
+    # @param email_id [String] the ID of the email in the Automation
+    # @return [HTTP::Response] the response from the API
+    def email_ecommerce_stats(automation_id:, email_id:, shop_id: nil, start_date: nil, end_date: nil)
+      uri = URI("#{MAILERLITE_API_URL}/automations/#{automation_id}/emails/#{email_id}/ecommerce-overview-stats")
+      query = { 'shop_id' => shop_id, 'start_date' => start_date, 'end_date' => end_date }.compact
+      uri.query = URI.encode_www_form(query) unless query.empty?
+      client.http.get(uri)
+    end
+
+    # Returns the orders attributed to an automation
+    #
+    # @param automation_id [String] the ID of the Automation
+    # @param time_frame [String] week, month, two_months, three_months, six_months, year, last_year, all_time or custom
+    # @param time_frame_start [String] the first day, when time_frame is custom
+    # @param time_frame_end [String] the last day, when time_frame is custom
+    # @return [HTTP::Response] the response from the API
+    def ecommerce_orders(automation_id:, time_frame:, time_frame_start: nil, time_frame_end: nil, shop_id: nil, page: nil, limit: nil)
+      uri = URI("#{MAILERLITE_API_URL}/automations/#{automation_id}/order-activity")
+      uri.query = URI.encode_www_form({
+        'time_frame' => time_frame,
+        'time_frame_start' => time_frame_start,
+        'time_frame_end' => time_frame_end,
+        'ecommerce_shop_id' => shop_id,
+        'page' => page,
+        'limit' => limit
+      }.compact)
+      client.http.get(uri)
+    end
   end
 end

data/lib/mailerlite/brand_styles/brand_styles.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module MailerLite
+  # This is a class for the brand styles from MailerLite API.
+  class BrandStyles
+    attr_reader :client
+
+    # Inits the `BrandStyles` class with the specified `client`.
+    #
+    # @param client [MailerLite::Client] the `Client` instance to use
+    def initialize(client: MailerLite::Client.new)
+      @client = client
+    end
+
+    # Returns the palettes of the account: `brand` (the brand styles of the account, or nil if it has none),
+    # `default` and the `presets`. Match a palette on its `identifier`, not on its `name`.
+    # To apply a preset to an email, send its `identifier` in `brand.style` with `Emails#update_settings`.
+    #
+    # @return [HTTP::Response] the response from the API, with the `MailerLite::ApiResponse` methods
+    def get
+      Request.call(client, :get, '/brand-styles')
+    end
+  end
+end

data/lib/mailerlite/campaigns/campaigns.rb

@@ -3,6 +3,9 @@
 module MailerLite
   # This is a class for manipulating the Campaigns from MailerLite API.
   class Campaigns
+    # The value of `editor` in the emails of `create` for the simple editor.
+    EDITOR_SIMPLE = 'simple'
+
     attr_reader :client
 
     # Inits the `Campaigns` class with the specified `client`.
@@ -34,7 +37,13 @@ module MailerLite
     # @param name [String] Maximum string length of 255 characters
     # @param language_id [integer] Used to define the language in the unsubscribe template. Must be a valid language id. Defaults to english
     # @param type [String] Must be one of the following: regular, ab, resend. Type resend is only available for accounts on growing or advanced plans
-    # @param emails [Array] Must contain 1 email object item
+    # @param emails [Array] Must contain 1 email object item. The SDK sends each email as it is. An email can also have these keys:
+    #   - `editor`: set it to `simple` (`EDITOR_SIMPLE`) to create the email in the simple editor. Do not send `content` with it.
+    #     It must be the same on every email of the campaign. It is not available on every plan: for an account on a plan without it, the API returns an error.
+    #   - `template_id`: the simple editor template that the email starts from. It is a template from the shared gallery, or a template that you saved from your own email
+    #     with `Emails#create_template` (the `id` in its response). It is optional, and allowed only when `editor` is `simple`. Without it, the email starts from the
+    #     default blank template. The API copies the template into the new email and does not change the template. It must be the same on every email of the campaign.
+    #   Then edit the email with `MailerLite::Emails`. Its ID is in `data.emails[0].id` of the response.
     # @param groups [Array] Must contain valid group ids belonging to the account
     # @param segments [Array] Must contain valid segment ids belonging to the account. If both groups and segments are provided, only segments are used
     # @param ab_settings [Array<Array>] only if type is ab -  All items of the array are required
@@ -82,6 +91,7 @@ module MailerLite
     end
 
     # Update a new campaign with the specified details.
+    # Only `create` accepts `editor` and `template_id`.
     #
     # @param campaign_id [Integer] the ID of the campaign to update
     # @param name [String] Maximum string length of 255 characters
@@ -212,5 +222,27 @@ module MailerLite
     def languages
       client.http.get("#{MAILERLITE_API_URL}/campaigns/languages")
     end
+
+    # Returns the orders and revenue a campaign earned in one shop
+    #
+    # @param campaign_id [String] the ID of the campaign
+    # @param shop_id [String] the ID of the shop
+    # @return [HTTP::Response] the response from the API
+    def ecommerce_stats(campaign_id:, shop_id:)
+      uri = URI("#{MAILERLITE_API_URL}/campaigns/#{campaign_id}/reports/ecommerce")
+      uri.query = URI.encode_www_form('shop_id' => shop_id)
+      client.http.get(uri)
+    end
+
+    # Returns the orders attributed to a campaign in one shop
+    #
+    # @param campaign_id [String] the ID of the campaign
+    # @param shop_id [String] the ID of the shop
+    # @return [HTTP::Response] the response from the API
+    def ecommerce_orders(campaign_id:, shop_id:, page: nil, limit: nil)
+      uri = URI("#{MAILERLITE_API_URL}/campaigns/#{campaign_id}/reports/ecommerce/orders")
+      uri.query = URI.encode_www_form({ 'shop_id' => shop_id, 'page' => page, 'limit' => limit }.compact)
+      client.http.get(uri)
+    end
   end
 end

data/lib/mailerlite/ecommerce/ecommerce.rb

@@ -0,0 +1,316 @@
+# frozen_string_literal: true
+
+module MailerLite
+  # Classes for manipulating e-commerce data from MailerLite API.
+  module Ecommerce
+    # Shared setup for the e-commerce classes.
+    class Resource
+      attr_reader :client
+
+      # Inits the class with the specified `client`.
+      #
+      # @param client [MailerLite::Client] the `Client` instance to use
+      def initialize(client: MailerLite::Client.new)
+        @client = client
+      end
+
+      private
+
+      def shop_url(shop_id, path = '')
+        "#{MAILERLITE_API_URL}/ecommerce/shops/#{shop_id}#{path}"
+      end
+
+      def get_with_query(url, filter: {}, **params)
+        query = filter.to_h { |key, value| ["filter[#{key}]", value] }.merge(params.transform_keys(&:to_s)).compact
+        uri = URI(url)
+        uri.query = URI.encode_www_form(query) unless query.empty?
+        client.http.get(uri)
+      end
+    end
+
+    # Shops from MailerLite API.
+    class Shops < Resource
+      # @return [HTTP::Response] the response from the API
+      def list(page: nil, limit: nil)
+        get_with_query("#{MAILERLITE_API_URL}/ecommerce/shops", page: page, limit: limit)
+      end
+
+      # @param shop_id [String] the ID of the shop
+      # @return [HTTP::Response] the response from the API
+      def get(shop_id)
+        client.http.get(shop_url(shop_id))
+      end
+
+      # @param params [Hash] name, url and currency are required
+      # @return [HTTP::Response] the response from the API
+      def create(params)
+        client.http.post("#{MAILERLITE_API_URL}/ecommerce/shops", json: params)
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def update(shop_id:, params:)
+        client.http.put(shop_url(shop_id), json: params)
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def delete(shop_id)
+        client.http.delete(shop_url(shop_id))
+      end
+
+      # @param start_date [String] the first day, e.g. 2026-01-01
+      # @param end_date [String] the last day, included
+      # @return [HTTP::Response] the response from the API
+      def stats(shop_id:, start_date:, end_date:)
+        get_with_query(shop_url(shop_id, '/reports/stats'), start_date: start_date, end_date: end_date)
+      end
+    end
+
+    # Products from MailerLite API.
+    class Products < Resource
+      # @param filter [Hash] name, type, enabled, category or exclude_from_automations
+      # @return [HTTP::Response] the response from the API
+      def list(shop_id:, filter: {}, sort: nil, page: nil, limit: nil)
+        get_with_query(shop_url(shop_id, '/products'), filter: filter, sort: sort, page: page, limit: limit)
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def get(shop_id:, product_id:)
+        client.http.get(shop_url(shop_id, "/products/#{product_id}"))
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def create(shop_id:, params:)
+        client.http.post(shop_url(shop_id, '/products'), json: params)
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def update(shop_id:, product_id:, params:)
+        client.http.put(shop_url(shop_id, "/products/#{product_id}"), json: params)
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def delete(shop_id:, product_id:)
+        client.http.delete(shop_url(shop_id, "/products/#{product_id}"))
+      end
+
+      # @param enabled [Boolean] whether the product is enabled
+      # @return [HTTP::Response] the response from the API
+      def change_status(shop_id:, product_id:, enabled:)
+        client.http.put(shop_url(shop_id, "/products/#{product_id}/change-status"), json: { status: enabled })
+      end
+
+      # @param replace [Boolean] also remove the categories that are not listed
+      # @return [HTTP::Response] the response from the API
+      def assign_categories(shop_id:, product_id:, category_ids:, replace: false)
+        client.http.put(shop_url(shop_id, "/products/#{product_id}/categories/multiple"), json: { categories: category_ids, replace: replace })
+      end
+    end
+
+    # Product variants from MailerLite API.
+    class ProductVariants < Resource
+      # @return [HTTP::Response] the response from the API
+      def list(shop_id:, product_id:)
+        client.http.get(shop_url(shop_id, "/products/#{product_id}/variants"))
+      end
+
+      # @param variants [Array<Hash>] name and attributes are required
+      # @return [HTTP::Response] the response from the API
+      def sync(shop_id:, product_id:, variants:)
+        client.http.post(shop_url(shop_id, "/products/#{product_id}/variants"), json: variants)
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def update(shop_id:, product_id:, variant_id:, params:)
+        client.http.put(shop_url(shop_id, "/products/#{product_id}/variants/#{variant_id}"), json: params)
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def delete(shop_id:, product_id:, variant_id:)
+        client.http.delete(shop_url(shop_id, "/products/#{product_id}/variants/#{variant_id}"))
+      end
+    end
+
+    # Categories from MailerLite API.
+    class Categories < Resource
+      # @return [HTTP::Response] the response from the API
+      def list(shop_id:, filter: {}, page: nil, limit: nil)
+        get_with_query(shop_url(shop_id, '/categories'), filter: filter, page: page, limit: limit)
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def get(shop_id:, category_id:)
+        client.http.get(shop_url(shop_id, "/categories/#{category_id}"))
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def create(shop_id:, params:)
+        client.http.post(shop_url(shop_id, '/categories'), json: params)
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def update(shop_id:, category_id:, params:)
+        client.http.put(shop_url(shop_id, "/categories/#{category_id}"), json: params)
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def delete(shop_id:, category_id:)
+        client.http.delete(shop_url(shop_id, "/categories/#{category_id}"))
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def products(shop_id:, category_id:, page: nil, limit: nil)
+        get_with_query(shop_url(shop_id, "/categories/#{category_id}/products"), page: page, limit: limit)
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def assign_product(shop_id:, category_id:, product_id:)
+        client.http.put(shop_url(shop_id, "/categories/#{category_id}/products/#{product_id}"))
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def unassign_product(shop_id:, category_id:, product_id:)
+        client.http.delete(shop_url(shop_id, "/categories/#{category_id}/products/#{product_id}"))
+      end
+    end
+
+    # Customers from MailerLite API.
+    class Customers < Resource
+      # @param filter [Hash] email
+      # @return [HTTP::Response] the response from the API
+      def list(shop_id:, filter: {}, sort: nil, page: nil, limit: nil)
+        get_with_query(shop_url(shop_id, '/customers'), filter: filter, sort: sort, page: page, limit: limit)
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def get(shop_id:, customer_id:)
+        client.http.get(shop_url(shop_id, "/customers/#{customer_id}"))
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def create(shop_id:, params:)
+        client.http.post(shop_url(shop_id, '/customers'), json: params)
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def update(shop_id:, customer_id:, params:)
+        client.http.put(shop_url(shop_id, "/customers/#{customer_id}"), json: params)
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def delete(shop_id:, customer_id:)
+        client.http.delete(shop_url(shop_id, "/customers/#{customer_id}"))
+      end
+    end
+
+    # Orders from MailerLite API.
+    class Orders < Resource
+      # @param filter [Hash] status, customer, attributed or email_id
+      # @return [HTTP::Response] the response from the API
+      def list(shop_id:, filter: {}, sort: nil, page: nil, limit: nil)
+        get_with_query(shop_url(shop_id, '/orders'), filter: filter, sort: sort, page: page, limit: limit)
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def get(shop_id:, order_id:)
+        client.http.get(shop_url(shop_id, "/orders/#{order_id}"))
+      end
+
+      # @param params [Hash] customer and cart are required
+      # @return [HTTP::Response] the response from the API
+      def create(shop_id:, params:)
+        client.http.post(shop_url(shop_id, '/orders'), json: params)
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def update(shop_id:, order_id:, params:)
+        client.http.put(shop_url(shop_id, "/orders/#{order_id}"), json: params)
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def delete(shop_id:, order_id:)
+        client.http.delete(shop_url(shop_id, "/orders/#{order_id}"))
+      end
+    end
+
+    # Carts from MailerLite API.
+    class Carts < Resource
+      # @return [HTTP::Response] the response from the API
+      def list(shop_id:, page: nil, limit: nil)
+        get_with_query(shop_url(shop_id, '/carts'), page: page, limit: limit)
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def get(shop_id:, cart_id:)
+        client.http.get(shop_url(shop_id, "/carts/#{cart_id}"))
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def update(shop_id:, cart_id:, params:)
+        client.http.put(shop_url(shop_id, "/carts/#{cart_id}"), json: params)
+      end
+    end
+
+    # Cart items from MailerLite API.
+    class CartItems < Resource
+      # @return [HTTP::Response] the response from the API
+      def list(shop_id:, cart_id:, page: nil, limit: nil)
+        get_with_query(shop_url(shop_id, "/carts/#{cart_id}/items"), page: page, limit: limit)
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def get(shop_id:, cart_id:, item_id:)
+        client.http.get(shop_url(shop_id, "/carts/#{cart_id}/items/#{item_id}"))
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def create(shop_id:, cart_id:, params:)
+        client.http.post(shop_url(shop_id, "/carts/#{cart_id}/items"), json: params)
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def update(shop_id:, cart_id:, item_id:, params:)
+        client.http.put(shop_url(shop_id, "/carts/#{cart_id}/items/#{item_id}"), json: params)
+      end
+
+      # @return [HTTP::Response] the response from the API
+      def delete(shop_id:, cart_id:, item_id:)
+        client.http.delete(shop_url(shop_id, "/carts/#{cart_id}/items/#{item_id}"))
+      end
+    end
+
+    # Bulk imports from MailerLite API.
+    class Imports < Resource
+      # @param products [Array<Hash>] the products to import
+      # @return [HTTP::Response] the response from the API
+      def products(shop_id:, products:)
+        client.http.post(shop_url(shop_id, '/products/import'), json: products)
+      end
+
+      # @param categories [Array<Hash>] the categories to import
+      # @return [HTTP::Response] the response from the API
+      def categories(shop_id:, categories:)
+        client.http.post(shop_url(shop_id, '/categories/import'), json: categories)
+      end
+
+      # @param customers [Array<Hash>] the customers to import
+      # @return [HTTP::Response] the response from the API
+      def customers(shop_id:, customers:)
+        client.http.post(shop_url(shop_id, '/customers/import'), json: customers)
+      end
+
+      # @param orders [Array<Hash>] the orders to import
+      # @return [HTTP::Response] the response from the API
+      def orders(shop_id:, orders:)
+        client.http.post(shop_url(shop_id, '/orders/import'), json: { orders: orders })
+      end
+    end
+
+    # E-commerce tracking settings from MailerLite API.
+    class Settings < Resource
+      # @return [HTTP::Response] the response from the API
+      def get
+        client.http.get("#{MAILERLITE_API_URL}/ecommerce/settings")
+      end
+    end
+  end
+end