exporto_api 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 18c37f30a8751a2ca78301ecb299f4b3caf58958442d8d66b03bc6d2f62aa796
+  data.tar.gz: 1919fdc84b42b1b74542c61778fe9ccd82339bc7294afa77e0f0b7ca3c9d1b14
+SHA512:
+  metadata.gz: 583ed97d21592c273c8e9ccb1e8f95634a0e1dfac4ab6c0c7f71e5d2b28c19071ccfe1a7c60a96fb2ab58ab3a0dee3e433ce83d2e59c2c575e1a2c56caa66a18
+  data.tar.gz: 97c0adbe8af0faf45090f10ed227204da9d37b945593b7cca964d098ba0f40bfeafa9ad9fa6214cbe8f30164410337ff70f0d27824721086729620be945b7de3

data/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+## [Unreleased]
+
+## [0.1.0] - 2026-09-02
+
+### Added
+
+- Rails-independent live and staging clients with injectable Faraday adapters.
+- OAuth client-credentials authentication and Bearer-authenticated API requests.
+- Snake-case response objects with deeply frozen access to the original provider response.
+- Typed authentication, validation, not-found, rate-limit, server, and transport errors with safe metadata.
+- Label-method discovery through `client.label_method.all`.
+- Shipment search and retrieval through `client.shipment.search` and `client.shipment.find`.
+- Label creation through `client.label.create` without automatic mutation retries.
+- Return-shipment registration through `client.return_shipment.create`, returning a typed success response for every `2xx` response.
+
+### Out of scope
+
+- Token caching, expiry buffers, refresh, and concurrency policy remain caller responsibilities.
+- Shipment deletion and carrier-label cancellation are not part of the initial public API.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 PostCo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,189 @@
+# ExportoAPI
+
+Rails-independent Ruby client for the Exporto API.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "exporto_api", "~> 0.1.0"
+```
+
+Then run `bundle install`.
+
+## Usage
+
+### Initialize clients
+
+Exporto uses a separate OAuth client to issue an access token. Set the environment once and pass the same `sandbox:` value to both clients so the token is used only in the environment that issued it.
+
+```ruby
+require "exporto_api"
+
+sandbox = true # Use Exporto's staging environment
+
+auth_client = ExportoAPI::AuthClient.new(
+  username: "EXPORTO_USERNAME",
+  password: "EXPORTO_PASSWORD",
+  sandbox: sandbox
+)
+
+token = auth_client.token
+
+client = ExportoAPI::Client.new(
+  access_token: token.access_token,
+  sandbox: sandbox
+)
+```
+
+`AuthClient#token` also accepts an optional space-delimited `scope:` string. Its response exposes `access_token`, `token_type`, `expires_in`, and `scope`.
+
+The gem does not cache or refresh tokens. The caller owns token caching by Exporto account, environment, and requested scope, using the returned `expires_in` value and an application-defined safety buffer.
+
+### List label methods
+
+```ruby
+label_methods = client.label_method.all
+
+label_methods.each do |method|
+  puts [method.method_id, method.name, method.direction, method.carrier_name]
+end
+```
+
+The gem returns every method available to the authenticated account. The caller is responsible for selecting an approved method.
+
+### Search shipments
+
+```ruby
+shipments = client.shipment.search(
+  type: "outbound",
+  foreign_outbound_tracking_id: "OUTBOUND-TRACKING-ID",
+  page: 0,
+  page_size: 50
+)
+```
+
+Shipment search also accepts `foreign_inbound_tracking_id`, `processed_at`, `carrier_received_at_updated_at`, and `carrier_delivered_at_updated_at`.
+
+### Retrieve a shipment
+
+```ruby
+shipment = client.shipment.find(shipment_id: "EXPORTO-SHIPMENT-ID")
+
+puts shipment.shipment_id
+puts shipment.order_id
+puts shipment.status
+puts shipment.carrier_state
+```
+
+### Create a label
+
+Pass an Exporto-shaped payload to `client.label.create`:
+
+```ruby
+label = client.label.create(
+  "order" => {"customerFacingId" => "ORDER-123"},
+  "product" => {
+    "methodId" => 123,
+    "format" => "PDF"
+  },
+  "package" => {
+    "weight" => 1_000,
+    "reference" => "RETURN-123"
+  },
+  "address" => {
+    "name" => "Return Sender",
+    "line1" => "1 Example Street",
+    "city" => "London",
+    "postCode" => "SW1A 1AA",
+    "countryCode" => "GB",
+    "email" => "sender@example.com"
+  }
+)
+
+puts label.carrier_name
+puts label.tracking_code
+puts label.tracking_url
+```
+
+For an inbound label, `address` is the return sender's address. The account-specific `methodId` determines the carrier and shipment direction.
+
+### Register a return shipment
+
+```ruby
+registration = client.return_shipment.create(
+  order_id: "EXPORTO-ORDER-ID",
+  shipment_id: "POSTCO-GENERATED-SHIPMENT-ID",
+  foreign_inbound_tracking_id: label.tracking_code
+)
+
+registration.success # => true
+```
+
+Return-shipment registration maps its Ruby keyword arguments to Exporto's request body for `POST /order/return-shipment`. Provide exactly one of `order_id` or `customer_facing_id`, together with `shipment_id` and `foreign_inbound_tracking_id`. Because Exporto returns no response body for this operation, a successful `2xx` response returns an `ExportoAPI::Objects::ReturnShipmentResponse` with `success: true`; unsuccessful responses raise the corresponding `ExportoAPI` error.
+
+The gem does not automatically retry mutating requests. The caller owns idempotency, persistence, retry, and reconciliation policy.
+
+### Response objects
+
+Response objects expose Exporto's camel-case keys through snake-case Ruby methods, including nested hashes and arrays. The original provider response remains available as a deeply frozen snapshot through `raw`.
+
+```ruby
+shipment.shipment_id
+shipment.line_items.first.article_id
+shipment.raw
+shipment.raw.frozen? # => true
+```
+
+### Error handling
+
+HTTP failures raise typed subclasses of `ExportoAPI::Error`:
+
+```ruby
+begin
+  client.shipment.find(shipment_id: "EXPORTO-SHIPMENT-ID")
+rescue ExportoAPI::AuthenticationError => error
+  # 401/403 responses
+  puts error.message
+rescue ExportoAPI::ValidationError => error
+  # 400 responses
+  puts error.message
+rescue ExportoAPI::NotFoundError => error
+  # 404 responses
+  puts error.message
+rescue ExportoAPI::RateLimitError => error
+  # 429 responses
+  puts error.retry_after
+rescue ExportoAPI::ServerError => error
+  # 500-599 responses
+  puts error.message
+rescue ExportoAPI::APIError => error
+  # Other HTTP and transport failures
+  puts error.message
+end
+```
+
+Errors retain safe metadata where available through `status_code`, `request_id`, and `retry_after`. Transport failures retain the original Faraday exception as their cause.
+
+### Sandbox mode
+
+Both clients use Exporto's live environment by default. Set `sandbox: true` for staging, and always use the same value for token creation and authenticated requests:
+
+```ruby
+sandbox = false # Live: https://api.exporto.de/v1/
+# sandbox = true # Staging: https://staging.api.exporto.de/v1/
+```
+
+## Development
+
+```sh
+bundle install
+bundle exec rspec
+bundle exec standardrb
+gem build exporto_api.gemspec
+```
+
+## License
+
+MIT License. See [LICENSE.txt](LICENSE.txt).

data/lib/exporto_api/auth_client.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "faraday"
+
+module ExportoAPI
+  class AuthClient
+    attr_reader :username, :password, :adapter
+
+    def initialize(username:, password:, sandbox: false, adapter: Faraday.default_adapter)
+      @username = username
+      @password = password
+      @sandbox = sandbox
+      @adapter = adapter
+    end
+
+    def token(scope: nil)
+      auth.token(scope: scope)
+    end
+
+    def connection
+      @connection ||= Faraday.new do |connection|
+        connection.url_prefix = sandbox? ? Client::TEST_BASE_URL : Client::LIVE_BASE_URL
+        connection.headers["Accept"] = "application/json"
+        connection.request :authorization, :basic, username, password
+        connection.request :json
+        connection.response :json, content_type: /\bjson/
+        connection.adapter adapter
+      end
+    end
+
+    private
+
+    def auth
+      @auth ||= AuthResource.new(self)
+    end
+
+    def sandbox?
+      @sandbox
+    end
+  end
+end

data/lib/exporto_api/client.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "faraday"
+
+module ExportoAPI
+  class Client
+    LIVE_BASE_URL = "https://api.exporto.de/v1/"
+    TEST_BASE_URL = "https://staging.api.exporto.de/v1/"
+
+    attr_reader :access_token, :adapter
+
+    def initialize(access_token:, sandbox: false, adapter: Faraday.default_adapter)
+      @access_token = access_token
+      @sandbox = sandbox
+      @adapter = adapter
+    end
+
+    def label_method
+      @label_method ||= LabelMethodResource.new(self)
+    end
+
+    def shipment
+      @shipment ||= ShipmentResource.new(self)
+    end
+
+    def connection
+      @connection ||= Faraday.new do |connection|
+        connection.url_prefix = sandbox? ? TEST_BASE_URL : LIVE_BASE_URL
+        connection.headers["Authorization"] = "Bearer #{access_token}"
+        connection.headers["Accept"] = "application/json"
+        connection.request :json
+        connection.response :json, content_type: /\bjson/
+        connection.adapter adapter
+      end
+    end
+
+    def label
+      @label ||= LabelResource.new(self)
+    end
+
+    def return_shipment
+      @return_shipment ||= ReturnShipmentResource.new(self)
+    end
+
+    private
+
+    def sandbox?
+      @sandbox
+    end
+  end
+end

data/lib/exporto_api/errors.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ExportoAPI
+  class Error < StandardError
+    attr_reader :response, :status_code, :request_id, :retry_after
+
+    def initialize(message = nil, response: nil, status_code: nil, request_id: nil, retry_after: nil)
+      super(message)
+      @response = response
+      @status_code = status_code
+      @request_id = request_id
+      @retry_after = retry_after
+    end
+  end
+
+  class APIError < Error; end
+
+  class AuthenticationError < Error; end
+
+  class ValidationError < Error; end
+
+  class NotFoundError < Error; end
+
+  class RateLimitError < Error; end
+
+  class ServerError < Error; end
+end

data/lib/exporto_api/object.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "ostruct"
+require "active_support/core_ext/string/inflections"
+
+module ExportoAPI
+  class Base < OpenStruct
+    attr_reader :original_response
+
+    def self.new(attributes)
+      return attributes.map { |item| super(item) } if attributes.is_a?(Array)
+
+      super
+    end
+
+    def initialize(attributes)
+      @original_response = deep_freeze(attributes)
+      super(to_ostruct(attributes))
+    end
+
+    def to_hash
+      ostruct_to_hash(self)
+    end
+
+    alias_method :to_h, :to_hash
+
+    def raw
+      @original_response
+    end
+
+    private
+
+    def to_ostruct(object)
+      case object
+      when Hash
+        OpenStruct.new(
+          object.transform_keys { |key| key.to_s.underscore }
+            .transform_values { |value| to_ostruct(value) }
+        )
+      when Array
+        object.map { |value| to_ostruct(value) }
+      else
+        object
+      end
+    end
+
+    def deep_freeze(object)
+      case object
+      when Hash then object.transform_values { |value| deep_freeze(value) }.freeze
+      when Array then object.map { |item| deep_freeze(item) }.freeze
+      else object.respond_to?(:freeze) ? object.freeze : object
+      end
+    end
+
+    def ostruct_to_hash(object)
+      case object
+      when OpenStruct
+        object.each_pair.to_h
+          .transform_keys(&:to_s)
+          .transform_values { |value| ostruct_to_hash(value) }
+      when Array
+        object.map { |value| ostruct_to_hash(value) }
+      when Hash
+        object.transform_keys(&:to_s)
+          .transform_values { |value| ostruct_to_hash(value) }
+      else
+        object
+      end
+    end
+  end
+end

data/lib/exporto_api/objects/label_method_response.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ExportoAPI
+  module Objects
+    class LabelMethodResponse < Base; end
+  end
+end

data/lib/exporto_api/objects/label_response.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ExportoAPI
+  module Objects
+    class LabelResponse < Base; end
+  end
+end

data/lib/exporto_api/objects/return_shipment_response.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ExportoAPI
+  module Objects
+    class ReturnShipmentResponse < Base; end
+  end
+end

data/lib/exporto_api/objects/shipment_response.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ExportoAPI
+  module Objects
+    class ShipmentResponse < Base; end
+  end
+end

data/lib/exporto_api/objects/token_response.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ExportoAPI
+  module Objects
+    class TokenResponse < Base; end
+  end
+end

data/lib/exporto_api/resource.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "json"
+
+module ExportoAPI
+  class Resource
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    private
+
+    def get_request(path, params: {}, headers: {})
+      handle_response(client.connection.get(path, params, headers))
+    rescue Faraday::Error => error
+      raise_transport_error(error)
+    end
+
+    def post_request(path, body:, headers: {})
+      handle_response(client.connection.post(path, body, headers))
+    rescue Faraday::Error => error
+      raise_transport_error(error)
+    end
+
+    def handle_response(response)
+      body = parse_body(response.body)
+      return body if response.status.between?(200, 299)
+
+      error_class, prefix = error_mapping(response.status)
+      message = "#{prefix} (HTTP #{response.status}): #{extract_error_message(body)}"
+      raise error_class.new(
+        message,
+        response: response,
+        status_code: response.status,
+        request_id: extract_request_id(response, body),
+        retry_after: extract_retry_after(response)
+      )
+    end
+
+    def parse_body(body)
+      return body unless body.is_a?(String)
+
+      JSON.parse(body)
+    rescue JSON::ParserError
+      body
+    end
+
+    def extract_error_message(body)
+      case body
+      when Hash
+        [body["message"], body[:message], body["error"], body[:error]]
+          .find { |value| value.is_a?(String) } || "Unknown error"
+      when String then body
+      else "Unknown error"
+      end
+    end
+
+    def error_mapping(status)
+      case status
+      when 400 then [ValidationError, "Bad request"]
+      when 401, 403 then [AuthenticationError, "Authentication failed"]
+      when 404 then [NotFoundError, "Resource not found"]
+      when 429 then [RateLimitError, "Rate limited"]
+      when 500..599 then [ServerError, "Server error"]
+      else [APIError, "API error"]
+      end
+    end
+
+    def extract_request_id(response, body)
+      response.headers["x-request-id"] || request_id_from(body)
+    end
+
+    def request_id_from(body)
+      return unless body.is_a?(Hash)
+
+      body["requestId"] || body[:requestId] || body["request_id"] || body[:request_id]
+    end
+
+    def extract_retry_after(response)
+      Integer(response.headers["retry-after"], exception: false)
+    end
+
+    def raise_transport_error(error)
+      wrapped_error = APIError.new(
+        "Network request failed",
+        response: error.response,
+        status_code: error.response_status
+      )
+      raise wrapped_error, cause: error
+    end
+  end
+end

data/lib/exporto_api/resources/auth_resource.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ExportoAPI
+  class AuthResource < Resource
+    def token(scope: nil)
+      body = {"grant_type" => "client_credentials"}
+      body["scope"] = scope unless scope.nil?
+
+      Objects::TokenResponse.new(post_request("auth/token", body: body))
+    end
+  end
+end

data/lib/exporto_api/resources/label_method_resource.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ExportoAPI
+  class LabelMethodResource < Resource
+    def all
+      Objects::LabelMethodResponse.new(get_request("label/methods"))
+    end
+  end
+end

data/lib/exporto_api/resources/label_resource.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ExportoAPI
+  class LabelResource < Resource
+    def create(payload)
+      Objects::LabelResponse.new(post_request("label", body: payload))
+    end
+  end
+end

data/lib/exporto_api/resources/return_shipment_resource.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ExportoAPI
+  class ReturnShipmentResource < Resource
+    def create(
+      shipment_id:,
+      foreign_inbound_tracking_id:,
+      order_id: nil,
+      customer_facing_id: nil
+    )
+      body = {
+        "orderId" => order_id,
+        "customerFacingId" => customer_facing_id,
+        "shipmentId" => shipment_id,
+        "foreignInboundTrackingId" => foreign_inbound_tracking_id
+      }.compact
+
+      post_request("order/return-shipment", body: body)
+
+      # Exporto returns no response body for a successful return-shipment registration.
+      Objects::ReturnShipmentResponse.new(success: true)
+    end
+  end
+end

data/lib/exporto_api/resources/shipment_resource.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ExportoAPI
+  class ShipmentResource < Resource
+    def search(
+      foreign_outbound_tracking_id: nil,
+      foreign_inbound_tracking_id: nil,
+      processed_at: nil,
+      carrier_received_at_updated_at: nil,
+      carrier_delivered_at_updated_at: nil,
+      page: nil,
+      page_size: nil,
+      type: nil
+    )
+      params = {
+        "foreignOutboundTrackingId" => foreign_outbound_tracking_id,
+        "foreignInboundTrackingId" => foreign_inbound_tracking_id,
+        "processedAt" => processed_at,
+        "carrierReceivedAtUpdatedAt" => carrier_received_at_updated_at,
+        "carrierDeliveredAtUpdatedAt" => carrier_delivered_at_updated_at,
+        "page" => page,
+        "pageSize" => page_size,
+        "type" => type
+      }.compact
+
+      Objects::ShipmentResponse.new(get_request("shipment/search", params: params))
+    end
+
+    def find(shipment_id:)
+      Objects::ShipmentResponse.new(get_request("shipment/#{shipment_id}"))
+    end
+  end
+end

data/lib/exporto_api/version.rb

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

data/lib/exporto_api.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "exporto_api/version"
+
+module ExportoAPI
+  autoload :AuthClient, "exporto_api/auth_client"
+  autoload :Client, "exporto_api/client"
+  autoload :Base, "exporto_api/object"
+  autoload :Resource, "exporto_api/resource"
+  autoload :Error, "exporto_api/errors"
+  autoload :APIError, "exporto_api/errors"
+  autoload :AuthenticationError, "exporto_api/errors"
+  autoload :ValidationError, "exporto_api/errors"
+  autoload :NotFoundError, "exporto_api/errors"
+  autoload :RateLimitError, "exporto_api/errors"
+  autoload :ServerError, "exporto_api/errors"
+  autoload :AuthResource, "exporto_api/resources/auth_resource"
+  autoload :LabelResource, "exporto_api/resources/label_resource"
+  autoload :LabelMethodResource, "exporto_api/resources/label_method_resource"
+  autoload :ReturnShipmentResource, "exporto_api/resources/return_shipment_resource"
+  autoload :ShipmentResource, "exporto_api/resources/shipment_resource"
+
+  module Objects
+    autoload :LabelResponse, "exporto_api/objects/label_response"
+    autoload :LabelMethodResponse, "exporto_api/objects/label_method_response"
+    autoload :ReturnShipmentResponse, "exporto_api/objects/return_shipment_response"
+    autoload :ShipmentResponse, "exporto_api/objects/shipment_response"
+    autoload :TokenResponse, "exporto_api/objects/token_response"
+  end
+end

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: exporto_api
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- PostCo
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-09-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: faraday-net_http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A small Ruby client foundation for integrating with Exporto without depending
+  on Rails.
+email:
+- engineering@postco.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/exporto_api.rb
+- lib/exporto_api/auth_client.rb
+- lib/exporto_api/client.rb
+- lib/exporto_api/errors.rb
+- lib/exporto_api/object.rb
+- lib/exporto_api/objects/label_method_response.rb
+- lib/exporto_api/objects/label_response.rb
+- lib/exporto_api/objects/return_shipment_response.rb
+- lib/exporto_api/objects/shipment_response.rb
+- lib/exporto_api/objects/token_response.rb
+- lib/exporto_api/resource.rb
+- lib/exporto_api/resources/auth_resource.rb
+- lib/exporto_api/resources/label_method_resource.rb
+- lib/exporto_api/resources/label_resource.rb
+- lib/exporto_api/resources/return_shipment_resource.rb
+- lib/exporto_api/resources/shipment_resource.rb
+- lib/exporto_api/version.rb
+homepage: https://github.com/PostCo/exporto_api
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/PostCo/exporto_api
+  changelog_uri: https://github.com/PostCo/exporto_api/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Rails-independent Ruby client for the Exporto API
+test_files: []