econt 0.1.0

data/lib/econt/services/nomenclatures/nomenclatures.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Econt
+  module Services
+    module Nomenclatures
+      class Nomenclatures < ServiceResource
+        include Econt::Services::Nomenclatures
+
+        # List countries available for delivery.
+        # @note Read. Does not change shipment state.
+        # @return [Econt::Collection<Econt::Models::Nomenclatures::Country>]
+        #   Check #error? before using data.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#get_countries Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   nomenclatures = Econt::Services::Nomenclatures::Nomenclatures.new
+        #   countries = nomenclatures.get_countries
+        def get_countries
+          response = post('getCountries')
+          collection(response, Econt::Models::Nomenclatures::Country)
+          # http://ee.econt.com/services/Nomenclatures/NomenclaturesService.getCountries.json(.soap?wsdl)
+        end
+
+        # List cities for a country.
+        # @note Read. Does not change shipment state.
+        # @param country_code [String] ISO country code, such as BGR.
+        # @return [Econt::Collection<Econt::Models::Nomenclatures::City>]
+        #   Check #error? before using data.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#get_cities Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   nomenclatures = Econt::Services::Nomenclatures::Nomenclatures.new
+        #   cities = nomenclatures.get_cities(country_code: 'BGR')
+        def get_cities(country_code:)
+          response = post('getCities', body: { country_code: country_code })
+          collection(response, Econt::Models::Nomenclatures::City)
+          # http://ee.econt.com/services/Nomenclatures/NomenclaturesService.getCities.json(.soap?wsdl)
+        end
+
+        # Fetch cities and derive unique, sorted region names; this is a local helper, not a separate endpoint.
+        # @note Read. Does not change shipment state.
+        # @param country_code [String] Country code.
+        # @param language [String, nil] Only en selects English names; nil and other values select native names.
+        # @return [Array<String>] Unique, sorted region names; no #error? reader.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#get_regions Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   nomenclatures = Econt::Services::Nomenclatures::Nomenclatures.new
+        #   regions = nomenclatures.get_regions(country_code: 'BGR', language: 'en')
+        def get_regions(country_code:, language: nil)
+          region_field = language.to_s.casecmp('en').zero? ? :region_name_en : :region_name
+          cities = get_cities(country_code: country_code)
+          cities.filter_map { |city| city.send(region_field) }.uniq.sort
+        end
+
+        # List offices with optional city and reception filters.
+        # @note Read. Does not change shipment state.
+        # @param country_code [String] Country code.
+        # @param city_id [Integer, nil] City identifier.
+        # @param show_cargo_receptions [Boolean, nil] Include cargo receptions.
+        # @param show_lc [Boolean, nil] Carrier LC filter.
+        # @param serving_receptions [Boolean, nil] Carrier serving-reception filter.
+        # @return [Econt::Collection<Econt::Models::Nomenclatures::Office>]
+        #   Check #error? before using data.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#get_offices Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   nomenclatures = Econt::Services::Nomenclatures::Nomenclatures.new
+        #   offices = nomenclatures.get_offices(country_code: 'BGR', city_id: 41)
+        def get_offices(country_code:, city_id: nil, show_cargo_receptions: nil, show_lc: nil, serving_receptions: nil)
+          response = post('getOffices', body: {
+                            country_code: country_code,
+                            city_id: city_id,
+                            show_cargo_receptions: show_cargo_receptions,
+                            show_lc: show_lc,
+                            serving_receptions: serving_receptions
+                          })
+          collection(response, Econt::Models::Nomenclatures::Office)
+          # http://ee.econt.com/services/Nomenclatures/NomenclaturesService.getOffices.json(.soap?wsdl)
+        end
+
+        # List streets, optionally restricted to a city.
+        # @note Read. Does not change shipment state.
+        # @param city_id [Integer, nil] City identifier.
+        # @return [Econt::Collection<Econt::Models::Nomenclatures::Street>]
+        #   Check #error? before using data.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#get_streets Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   nomenclatures = Econt::Services::Nomenclatures::Nomenclatures.new
+        #   streets = nomenclatures.get_streets(city_id: 41)
+        def get_streets(city_id: nil)
+          response = post('getStreets', body: { city_id: city_id })
+          collection(response, Econt::Models::Nomenclatures::Street)
+          # http://ee.econt.com/services/Nomenclatures/NomenclaturesService.getStreets.json(.soap?wsdl)
+        end
+
+        # List quarters, optionally restricted to a city.
+        # @note Read. Does not change shipment state.
+        # @param city_id [Integer, nil] City identifier.
+        # @return [Econt::Collection<Econt::Models::Nomenclatures::Quarter>]
+        #   Check #error? before using data.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#get_quarters Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   nomenclatures = Econt::Services::Nomenclatures::Nomenclatures.new
+        #   quarters = nomenclatures.get_quarters(city_id: 41)
+        def get_quarters(city_id: nil)
+          response = post('getQuarters', body: { city_id: city_id })
+          collection(response, Econt::Models::Nomenclatures::Quarter)
+          # http://ee.econt.com/services/Nomenclatures/NomenclaturesService.getQuarters.json(.soap?wsdl)
+        end
+      end
+    end
+  end
+end

data/lib/econt/services/nomenclatures.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Econt
+  module Services
+    module Nomenclatures
+      def service_url
+        'Nomenclatures'
+      end
+    end
+  end
+end

data/lib/econt/services/payment_report/payment_report.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Econt
+  module Services
+    module PaymentReport
+      class PaymentReport < ServiceResource
+        include Econt::Services::PaymentReport
+
+        # POST /services/PaymentReport/PaymentReportService.PaymentReport.json(.soap?wsdl)
+        # Read payment reports for an optional date range.
+        # @note Read. Does not change shipment state.
+        # @param date_to [String, nil] End date in carrier format.
+        # @param date_from [String, nil] Start date in carrier format.
+        # @return [Econt::Collection, Econt::Models::PaymentReport::PaymentReportRow]
+        #   Check #error? before using data.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#payment_report Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   reports = Econt::Services::PaymentReport::PaymentReport.new
+        #   rows = reports.payment_report(date_from: '2026-10-01', date_to: '2026-10-12')
+        #   rows = rows.is_a?(Econt::Collection) ? rows.to_a : [rows]
+        def payment_report(date_to: nil, date_from: nil)
+          response = post('PaymentReport', body: { date_to:, date_from: })
+          if response.body.is_a?(Hash) && response.body.key?('PaymentReportRows')
+            return Econt::Collection.new(response.body, model: Econt::Models::PaymentReport::PaymentReportRow,
+                                                        key: :payment_report_rows)
+          end
+
+          resource(response, Econt::Models::PaymentReport::PaymentReportRow)
+        end
+      end
+    end
+  end
+end

data/lib/econt/services/payment_report.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Econt
+  module Services
+    module PaymentReport
+      def service_url
+        'PaymentReport'
+      end
+    end
+  end
+end

data/lib/econt/services/profile/profile.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Econt
+  module Services
+    module Profile
+      class Profile < ServiceResource
+        include Econt::Services::Profile
+
+        resource_type 'Profile'
+
+        # POST /services/Profile/ProfileService.getClientProfiles.json(.soap?wsdl)
+        # Read account client profiles and payment settings.
+        # @note Read. Does not change shipment state.
+        # @return [Econt::Collection<Econt::Models::Profile::ProfilesResponseElement>]
+        #   Check #error? before using data.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#get_client_profiles Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   profiles = Econt::Services::Profile::Profile.new
+        #   clients = profiles.get_client_profiles
+        def get_client_profiles
+          response = post('getClientProfiles')
+          collection(response, Econt::Models::Profile::ProfilesResponseElement)
+        end
+
+        # POST /services/Profile/ProfileService.createCDAgreement.json(.soap?wsdl)
+        # Create a cash-on-delivery payment agreement.
+        # @note Mutation. Review account permissions and cleanup before calling.
+        # @param cd_pay_options [Hash] CDPayOptions payload; account eligibility is carrier-controlled.
+        # @return [Econt::Models::Profile::CDPayOptions] Typed result; inspect #error? before using data.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#create_cd_agreement Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   profiles = Econt::Services::Profile::Profile.new
+        #   agreement = profiles.create_cd_agreement(cd_pay_options: cd_pay_options_payload)
+        def create_cd_agreement(cd_pay_options:)
+          response = post('createCDAgreement', body: { cd_pay_options: cd_pay_options })
+          resource(response, Econt::Models::Profile::CDPayOptions, key: :cd_pay_options)
+        end
+      end
+    end
+  end
+end

data/lib/econt/services/profile.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Econt
+  module Services
+    module Profile
+      def service_url
+        'Profile'
+      end
+    end
+  end
+end

data/lib/econt/services/shipments/label.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module Econt
+  module Services
+    module Shipments
+      class Label < ServiceResource
+        include Econt::Services::Shipments
+
+        resource_type 'Label'
+
+        # POST /services/Shipments/LabelService.createLabel.json(.soap?wsdl)
+        # Calculate, validate, or create one shipping label.
+        # @note Conditional mutation. Review account permissions and cleanup before calling.
+        # @param label [Hash, nil] Shipping-label payload.
+        # @param request_courier_time_from [String, nil] Requested courier window start.
+        # @param request_courier_time_to [String, nil] Requested courier window end.
+        # @param mode [String, nil] calculate or validate are non-mutating; create and calculate_with_block have
+        #   effects. Always choose explicitly.
+        # @return [Econt::Models::Shipments::CreateLabelResultElement] Typed result; inspect #error? before using data.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#create_label Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   labels = Econt::Services::Shipments::Label.new
+        #   quote = labels.create_label(label: label_payload, mode: 'calculate')
+        def create_label(label: nil, request_courier_time_from: nil, request_courier_time_to: nil, mode: nil)
+          response = post('createLabel', body: {
+                            label: label,
+                            request_courier_time_from: request_courier_time_from,
+                            request_courier_time_to: request_courier_time_to,
+                            mode: mode
+                          })
+          resource(response, Econt::Models::Shipments::CreateLabelResultElement)
+        end
+
+        # POST /services/Shipments/LabelService.createLabels.json(.soap?wsdl)
+        # Calculate, validate, or create a batch of labels.
+        # @note Conditional mutation. Review account permissions and cleanup before calling.
+        # @param labels [Array<Hash>] Shipping-label payloads.
+        # @param run_async_and_email_result_to [String, nil] Email address for asynchronous results; the returned
+        #   data may differ.
+        # @param mode [String, nil] Choose calculate, validate, or create explicitly.
+        # @return [Econt::Collection<Econt::Models::Shipments::CreateLabelResultElement>]
+        #   Check #error? before using data.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#create_labels Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   labels = Econt::Services::Shipments::Label.new
+        #   quotes = labels.create_labels(labels: [label_payload], mode: 'calculate')
+        def create_labels(labels: [], run_async_and_email_result_to: nil, mode: nil)
+          response = post('createLabels', body: {
+                            labels: labels,
+                            run_async_and_email_result_to: run_async_and_email_result_to,
+                            mode: mode
+                          })
+          collection(response, Econt::Models::Shipments::CreateLabelResultElement)
+        end
+
+        # POST /services/Shipments/LabelService.deleteLabels.json(.soap?wsdl)
+        # Delete selected labels when allowed by carrier state and account permissions.
+        # @note Mutation. Review account permissions and cleanup before calling.
+        # @param shipment_numbers [Array<String>] Numbers of labels owned by your account.
+        # @return [Econt::Collection<Econt::Models::Shipments::DeleteLabelsResultElement>]
+        #   Check #error? before using data.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#delete_labels Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   labels = Econt::Services::Shipments::Label.new
+        #   deleted = labels.delete_labels(shipment_numbers: [shipment_number])
+        def delete_labels(shipment_numbers: [])
+          response = post('deleteLabels', body: { shipment_numbers: shipment_numbers })
+          collection(response, Econt::Models::Shipments::DeleteLabelsResultElement)
+        end
+
+        # POST /services/Shipments/LabelService.updateLabel.json(.soap?wsdl)
+        # Update or destroy an existing label.
+        # @note Mutation. Review account permissions and cleanup before calling.
+        # @param label [Hash, nil] Existing label with its shipment number and requested changes.
+        # @param request_courier_time_from [String, nil] Courier window start.
+        # @param request_courier_time_to [String, nil] Courier window end.
+        # @param destroy [Boolean, nil] Whether to destroy the label.
+        # @param payment_addition_price [Hash, nil] PaymentAdditionPrice fields.
+        # @param payment_instruction [Hash, nil] PaymentInstruction fields.
+        # @return [Econt::Models::Shipments::UpdateLabelResponse] Typed result; inspect #error? before using data.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#update_label Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   labels = Econt::Services::Shipments::Label.new
+        #   updated = labels.update_label(label: updated_label_payload, destroy: false)
+        def update_label(label: nil, request_courier_time_from: nil, request_courier_time_to: nil, destroy: nil,
+                         payment_addition_price: nil, payment_instruction: nil)
+          response = post('updateLabel', body: {
+                            label: label,
+                            request_courier_time_from: request_courier_time_from,
+                            request_courier_time_to: request_courier_time_to,
+                            destroy: destroy,
+                            payment_addition_price: payment_addition_price,
+                            payment_instruction: payment_instruction
+                          })
+          resource(response, Econt::Models::Shipments::UpdateLabelResponse)
+        end
+
+        # POST /services/Shipments/LabelService.checkPossibleShipmentEditions.json(.soap?wsdl)
+        # Check which edits are permitted for existing shipments.
+        # @note Read. Does not change shipment state.
+        # @param shipment_nums [Array<Integer>] Shipment numbers in the carrier field type.
+        # @return [Econt::Collection<Econt::Models::Shipments::CheckPossibleShipmentEditionsResultElement>]
+        #   Check #error? before using data.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#check_possible_shipment_editions Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   labels = Econt::Services::Shipments::Label.new
+        #   editions = labels.check_possible_shipment_editions(shipment_nums: [1234567890123])
+        def check_possible_shipment_editions(shipment_nums: [])
+          response = post('checkPossibleShipmentEditions', body: { shipment_nums: shipment_nums })
+          collection(response, Econt::Models::Shipments::CheckPossibleShipmentEditionsResultElement)
+        end
+
+        # POST /services/Shipments/LabelService.updateLabels.json(.soap?wsdl)
+        # Update several existing labels.
+        # @note Mutation. Review account permissions and cleanup before calling.
+        # @param labels [Array<Hash>] Existing labels and requested changes.
+        # @return [Econt::Collection<Econt::Models::Shipments::UpdateLabelsResultElement>]
+        #   Check #error? before using data.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#update_labels Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   labels = Econt::Services::Shipments::Label.new
+        #   updated = labels.update_labels(labels: [updated_label_payload])
+        def update_labels(labels: [])
+          response = post('updateLabels', body: { labels: labels })
+          collection(response, Econt::Models::Shipments::UpdateLabelsResultElement)
+        end
+
+        # POST /services/Shipments/LabelService.grouping.json(.soap?wsdl)
+        # Group existing labels into a group label.
+        # @note Mutation. Review account permissions and cleanup before calling.
+        # @param labels [Array<Integer>] Shipment numbers to group.
+        # @return [Econt::Models::Shipments::ShipmentStatus] Typed result; inspect #error? before using data.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#grouping Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   labels = Econt::Services::Shipments::Label.new
+        #   group = labels.grouping(labels: [1234567890123, 1234567890124])
+        def grouping(labels: [])
+          response = post('grouping', body: { labels: labels })
+          resource(response, Econt::Models::Shipments::ShipmentStatus, key: :label)
+        end
+
+        # POST /services/Shipments/LabelService.groupingCancelation.json(.soap?wsdl)
+        # Cancel an existing group label.
+        # @note Mutation. Review account permissions and cleanup before calling.
+        # @param group_label [Integer, nil] Group-label shipment number.
+        # @return [Econt::Models::Shipments::StatusResponse] Typed result; inspect #error? before using data.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#grouping_cancelation Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   labels = Econt::Services::Shipments::Label.new
+        #   result = labels.grouping_cancelation(group_label: group_label_number)
+        def grouping_cancelation(group_label: nil)
+          response = post('groupingCancelation', body: { group_label: group_label })
+          resource(response, Econt::Models::Shipments::StatusResponse)
+        end
+      end
+    end
+  end
+end

data/lib/econt/services/shipments/shipment.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Econt
+  module Services
+    module Shipments
+      class Shipment < ServiceResource
+        include Econt::Services::Shipments
+
+        resource_type 'Shipment'
+
+        # services/Shipments/ShipmentService.requestCourier.json(.soap?wsdl)
+        # Book a courier collection; pass the documented request fields as keywords.
+        # @note Mutation. Review account permissions and cleanup before calling.
+        # @param attributes [Hash] Courier payload as keywords: request_time_from, request_time_to, shipment_type,
+        #   shipment_pack_count, shipment_weight, sender_client, sender_agent, sender_address, attach_shipments,
+        #   pack12, cargo_vehicle_options.
+        # @return [Econt::Models::Shipments::RequestCourierResponse] Typed result; inspect #error? before using data.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#request_courier Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   shipments = Econt::Services::Shipments::Shipment.new
+        #   booking = shipments.request_courier(**courier_payload)
+        def request_courier(**attributes)
+          response = post('requestCourier', body: attributes)
+          resource(response, Econt::Models::Shipments::RequestCourierResponse)
+        end
+
+        # services/Shipments/ShipmentService.getShipmentStatuses.json(.soap?wsdl)
+        # Read shipment status, tracking events, and label information.
+        # @note Read. Does not change shipment state.
+        # @param shipment_numbers [Array<String>] Shipment numbers to query.
+        # @return [Econt::Collection<Econt::Models::Shipments::ShipmentStatusResultElement>]
+        #   Check #error? before using data.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#get_shipment_statuses Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   shipments = Econt::Services::Shipments::Shipment.new
+        #   statuses = shipments.get_shipment_statuses(shipment_numbers: [shipment_number])
+        def get_shipment_statuses(shipment_numbers: [])
+          response = post('getShipmentStatuses', body: { shipment_numbers: shipment_numbers })
+          collection(response, Econt::Models::Shipments::ShipmentStatusResultElement)
+        end
+
+        # services/Shipments/ShipmentService.getRequestCourierStatus.json(.soap?wsdl)
+        # Read the status of courier collection requests.
+        # @note Read. Does not change shipment state.
+        # @param request_courier_ids [Array<Integer>] Courier request identifiers.
+        # @return [Econt::Collection<Econt::Models::Shipments::RequestCourierStatusResultElement>]
+        #   Check #error? before using data.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#get_request_courier_status Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   shipments = Econt::Services::Shipments::Shipment.new
+        #   statuses = shipments.get_request_courier_status(request_courier_ids: [courier_request_id])
+        def get_request_courier_status(request_courier_ids: [])
+          response = post('getRequestCourierStatus', body: { request_courier_ids: request_courier_ids })
+          collection(response, Econt::Models::Shipments::RequestCourierStatusResultElement)
+        end
+
+        # services/Shipments/ShipmentService.getMyAWB.json(.soap?wsdl)
+        # List account waybills using optional date, page, and side filters.
+        # @note Read. Does not change shipment state.
+        # @param date_from [String, nil] Start date in carrier format.
+        # @param date_to [String, nil] End date in carrier format.
+        # @param page [Integer, nil] Requested page.
+        # @param side [String, nil] Carrier side filter; see getMyAWB documentation for allowed values.
+        # @return [Econt::Models::Shipments::GetMyAwbResponse] Typed result; inspect #error? before using data.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#get_my_awb Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   shipments = Econt::Services::Shipments::Shipment.new
+        #   waybills = shipments.get_my_awb(date_from: '2026-10-01', date_to: '2026-10-12', page: 1)
+        def get_my_awb(date_from: nil, date_to: nil, page: nil, side: nil)
+          body = { date_from: date_from, date_to: date_to, page: page, side: side }.compact
+          response = post('getMyAWB', body: body)
+          resource(response, Econt::Models::Shipments::GetMyAwbResponse)
+        end
+
+        # services/Shipments/ShipmentService.setITUCode.json(.soap?wsdl)
+        # Assign ITU transport metadata to a waybill.
+        # @note Mutation. Review account permissions and cleanup before calling.
+        # @param awb_barcode [String] Waybill barcode.
+        # @param truck_reg_num [String] Truck registration number.
+        # @param itu_code [String] ITU code; sent with the carrier spelling ITU_code.
+        # @return [Faraday::Response] Raw response; inspect #body.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#set_itu_code Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   shipments = Econt::Services::Shipments::Shipment.new
+        #   response = shipments.set_itu_code(
+        #     awb_barcode: shipment_number, truck_reg_num: truck_registration, itu_code: itu_code
+        #   )
+        #   response.body
+        def set_itu_code(awb_barcode:, truck_reg_num:, itu_code:)
+          post_raw('setITUCode', body: {
+                     'awbBarcode' => awb_barcode,
+                     'truckRegNum' => truck_reg_num,
+                     'ITU_code' => itu_code
+                   })
+        end
+      end
+    end
+  end
+end

data/lib/econt/services/shipments.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Econt
+  module Services
+    module Shipments
+      def service_url
+        'Shipments'
+      end
+    end
+  end
+end

data/lib/econt/services/three_way_logistics/three_way_logistics.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Econt
+  module Services
+    module ThreeWayLogistics
+      class ThreeWayLogistics < ServiceResource
+        include Econt::Services::ThreeWayLogistics
+
+        resource_type 'ThreeWayLogistics'
+
+        # Submit a three-way logistics request using legacy snake_case fields without camelCase conversion.
+        # @note Mutation. Review account permissions and cleanup before calling.
+        # @param attributes [Hash] Legacy request fields as keywords; see ThreeWayLogisticsRequest for available
+        #   field names.
+        # @return [Econt::Models::ThreeWayLogistics::ThreeWayLogisticsResponse]
+        #   Check #error? before using data.
+        # @raise [Econt::Error] On HTTP failure.
+        # @raise [Econt::TransportError] On connection, timeout, or TLS failure; inspect its subclass.
+        # @see file:docs/API.md#three_way_logistics Ruby usage and parameters
+        # @example After configuring Econt::Client
+        #   logistics = Econt::Services::ThreeWayLogistics::ThreeWayLogistics.new
+        #   result = logistics.three_way_logistics(**logistics_payload)
+        def three_way_logistics(**attributes)
+          response = post_raw('threeWayLogistics', body: attributes.transform_keys(&:to_s))
+          resource(response, Econt::Models::ThreeWayLogistics::ThreeWayLogisticsResponse)
+        end
+      end
+    end
+  end
+end

data/lib/econt/services/three_way_logistics.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Econt
+  module Services
+    module ThreeWayLogistics
+      def service_url
+        'ThreeWayLogistics'
+      end
+    end
+  end
+end

data/lib/econt/util.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Econt
+  module Util
+    module_function
+
+    def pluralize(word)
+      base = underscore(word.to_s.split('::').last)
+
+      if base.end_with?('y') && !base.end_with?('ay', 'ey', 'iy', 'oy', 'uy')
+        "#{base[0..-2]}ies"
+      elsif base.end_with?('s', 'x', 'z', 'ch', 'sh')
+        "#{base}es"
+      else
+        "#{base}s"
+      end
+    end
+
+    def camel_case(str)
+      str.gsub(/_([a-z])/) { ::Regexp.last_match(1).upcase }
+    end
+
+    def underscore(str)
+      str.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+         .gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+    end
+
+    def underscore_keys(hash)
+      return hash if primitive_value?(hash)
+
+      hash.each_with_object({}) do |(key, value), result|
+        result[underscore(key.to_s)] = case value
+                                       when Hash
+                                         underscore_keys(value)
+                                       when Array
+                                         value.map { |v| underscore_keys(v) }
+                                       else
+                                         value
+                                       end
+      end
+    end
+
+    def camelize_keys(hash)
+      hash.each_with_object({}) do |(key, value), result|
+        result[camel_case(key.to_s)] = case value
+                                       when Hash
+                                         camelize_keys(value)
+                                       when Array
+                                         value.map { |v| camelize_keys(v) }
+                                       else
+                                         value
+                                       end
+      end
+    end
+
+    def primitive_value?(value)
+      PRIMITIVE_TYPES.any? { |type| value.is_a?(type) }
+    end
+
+    PRIMITIVE_TYPES = [String, Symbol, Numeric, TrueClass, FalseClass, NilClass].freeze
+    private_constant :PRIMITIVE_TYPES
+  end
+end

data/lib/econt/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Econt
+  VERSION = '0.1.0'
+end