listo-delivery 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4550bd5dde54839887c33c6e4b6d3503f76511ff792fbe42a3892b3cfc8f4023
+  data.tar.gz: b03b099ec41ea855d5f64a65a43a61c72f75c6cd8c0941dcd84ed14016870e8e
+SHA512:
+  metadata.gz: 3fb3e87d92ffe548aae67303864a604ab4f3b998bbcd1e83d0c3a1622d02757273c59c3c57d90d0caa702e438536b3d29dd3e5d8c3f0cdbfce397711bee02779
+  data.tar.gz: c805469a01fcb20b242b100aceee19d3a5f662eeac069ba1836583172b1ef9a4ec7c4ecac629c23731363fc10e1ab1515b3b75d336c7daecfa69e0419a1e7f85

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cheto Labs, S.A.P.I. de C.V.
+
+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,152 @@
+# listo-delivery (Ruby)
+
+The official Ruby client for the Listo Delivery API. Standard library only
+(`net/http`, `json`, `openssl`, `securerandom`), Ruby 3.1 or newer.
+
+## Install
+
+```sh
+gem install listo-delivery
+```
+
+## Quickstart
+
+```ruby
+require "listo_delivery"
+
+client = ListoDelivery::Client.new(api_key: ENV.fetch("LISTO_API_KEY")) # lst_test_... or lst_live_...
+client.mode # => "test"
+
+store = "st_4bR8kM2wQ7xT1nV5cZ9pLdYe"
+quote = client.quotes.create(
+  store_id: store,
+  dropoff: {street: "Blvd. Puerta de Hierro 4965, Zapopan, Jalisco 45116"},
+  payment_method: "cash",
+  order_value_cents: 19_600
+)
+puts quote.fee_cents
+
+delivery = client.deliveries.create(
+  store_id: store,
+  quote_id: quote.id,
+  external_id: "order-1042",
+  payment_method: "cash",
+  order_value_cents: 19_600,
+  dropoff: {name: "Ana", phone: "+523312345678", street: "Blvd. Puerta de Hierro 4965, Zapopan, Jalisco 45116"},
+  idempotency_key: "order-1042" # your own order id makes a retry safe
+)
+puts delivery.id, delivery.status
+```
+
+The request fields are the API's wire names (`store_id`, `order_value_cents`).
+Pass them as keywords, as one Hash (`create({"store_id" => "..."})`), or both.
+Responses are model objects with a reader per documented field, `#to_h` and
+`#[]` by wire name; a field the API adds later is kept in `#to_h`, never a
+parsing error.
+
+Path parameters are positional: `client.deliveries.cancel(delivery_id, reason: "customer_canceled")`.
+Reads take their filters the same way: `client.deliveries.list(status: "pending")`.
+Every operation of the API is a method, named after it in snake_case
+(`deliveries.retrieve`, `stores.cancel_plan`, `ledger.list_for_store`, ...;
+`client.ping` lives on the client itself); the API reference at
+[docs.listo.delivery](https://docs.listo.delivery) lists them all.
+
+## Verify a webhook
+
+Verification needs the secret, not an API key, so it is also a plain module.
+Pass the body exactly as received (never re-serialized JSON):
+
+```ruby
+begin
+  event = ListoDelivery::Webhooks.construct_event(
+    request.body.read, request.headers["X-Listo-Signature"], ENV.fetch("LISTO_WEBHOOK_SECRET")
+  )
+rescue ListoDelivery::Error
+  head 400 # invalid_signature or invalid_payload: do not act on it
+else
+  case event
+  when ListoDelivery::Models::DeliveryStatusChangedEvent then event.data.status
+  end
+end
+```
+
+`construct_event` raises `ListoDelivery::SignatureError` when the signature
+does not verify, and `ListoDelivery::Error` with code `invalid_payload` when the
+signed body is not a JSON object; both are `ListoDelivery::Error`, so a receiver
+that answers 400 rescues `ListoDelivery::Error`. `ListoDelivery::Webhooks.verify(raw_body, signature_header, secrets)`
+returns true or false and never raises. `secrets` is one string or a list (two
+during a rotation); `tolerance:` (default 300 seconds, in both directions) and
+`now:` (unix seconds) are keywords. `client.webhooks.verify` and
+`client.webhooks.construct_event` are the same functions. An event whose
+`type` this SDK does not know comes back as a plain `Models::WebhookEvent`
+(`id`, `type`, `created_at`, and `data` as the raw Hash), never an error.
+
+## Errors
+
+Every non-2xx answer raises `ListoDelivery::Error` with `code` (branch on this),
+`message`, `param`, `retryable`, `status`, `request_id`, `doc_url` and the
+parsed `body`. A body that is not the API's error envelope (a proxy's HTML
+page) raises the same class with `code` `"http_<status>"`. A request that got
+no answer (DNS, refused, timeout) raises `ListoDelivery::ConnectionError`
+(`code` `"connection_error"`, `status` nil, `retryable` false: a write may
+have happened, so you decide). The API key is never put in an error message.
+
+```ruby
+begin
+  client.deliveries.retrieve("dlv_missing")
+rescue ListoDelivery::Error => e
+  warn "#{e.code} (#{e.status}) request #{e.request_id}"
+end
+```
+
+## Idempotency
+
+`deliveries.create`, `deliveries.refund`, `stores.create`, `stores.reactivate_plan`
+and `stores.cancel_plan` (the operations whose schema declares the
+`Idempotency-Key` header) accept `idempotency_key:`. Without one, a fresh UUID
+is sent per call and reused only by that call's own retries. No other
+operation sends the header, and passing `idempotency_key:` to one raises
+`ArgumentError` before any request (a body field really named that goes inside
+the Hash argument). An empty or blank key raises `ArgumentError` too.
+
+## Pagination
+
+Lists return the page as the API has it: `data`, `has_more` and `cursor`. Pass
+the cursor back to read the next page:
+
+```ruby
+cursor = nil
+loop do
+  page = client.deliveries.list(cursor: cursor)
+  page.data.each { |delivery| puts delivery.id }
+  break unless page.has_more
+
+  cursor = page.cursor
+end
+```
+
+## Retries and timeouts
+
+Nothing is retried by default. With `max_retries: n`, only a 429 is retried,
+after its `Retry-After` (seconds or an HTTP date, one second when missing,
+capped at 60), at most `n` times, with the same idempotency key. 5xx answers
+and network failures are never retried for you. `timeout:` (seconds, default
+30) bounds connecting, writing and reading.
+
+```ruby
+ListoDelivery::Client.new(api_key: key, max_retries: 2, timeout: 10, base_url: "https://api.listo.delivery")
+```
+
+## Differences from the other SDKs
+
+Ruby spells operations in snake_case, takes
+request fields as keywords or one Hash, and has no top-level `Listo`
+constant (it could clash with an application's own); the client is
+`ListoDelivery::Client`.
+
+## About this repository
+
+This code is generated from Listo's API definition. Issues and questions are
+welcome in this repository. Changes are made upstream by Listo and released
+here, so a pull request cannot be merged as it stands: open an issue and the
+change is made at the source.

data/lib/listo_delivery/client.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "openssl"
+require "securerandom"
+require "time"
+require "uri"
+
+module ListoDelivery
+  # The entry point: one Client per API key.
+  #
+  #   client = ListoDelivery::Client.new(api_key: ENV.fetch("LISTO_API_KEY"))
+  #   client.deliveries.retrieve("dlv_...")
+  #
+  # Resources (`deliveries`, `stores`, ...) and the root `ping` come from
+  # ClientOperations (generated); `client.webhooks` carries both the webhook
+  # operations and the signature helpers (`verify`, `construct_event`).
+  class Client
+    include ClientOperations
+
+    KEY_PREFIXES = {"lst_live_" => "live", "lst_test_" => "test"}.freeze
+    MAX_RETRY_WAIT = 60
+    DEFAULT_RETRY_WAIT = 1
+    # Transport failures that mean "no answer arrived".
+    NETWORK_ERRORS = [
+      SocketError, SystemCallError, IOError, Timeout::Error, OpenSSL::SSL::SSLError,
+      Net::HTTPBadResponse, Net::ProtocolError
+    ].freeze
+
+    # @return [String] "live" or "test", read from the key's prefix
+    attr_reader :mode
+    attr_reader :base_url, :max_retries, :timeout
+
+    # @param api_key [String] a `lst_live_` or `lst_test_` key
+    # @param base_url [String, nil] defaults to the schema's server
+    # @param max_retries [Integer] how many times a 429 is retried (0 = never)
+    # @param timeout [Numeric] seconds for connecting, writing and reading
+    def initialize(api_key:, base_url: nil, max_retries: 0, timeout: 30)
+      @mode = KEY_PREFIXES.find { |prefix, _| api_key.is_a?(String) && api_key.start_with?(prefix) }&.last
+      raise ArgumentError, "api_key must start with lst_live_ or lst_test_" unless @mode
+      raise ArgumentError, "max_retries must be a non-negative Integer" unless max_retries.is_a?(Integer) && max_retries >= 0
+      raise ArgumentError, "timeout must be a positive number" unless timeout.is_a?(Numeric) && timeout.positive?
+
+      @api_key = api_key
+      @base_url = (base_url || DEFAULT_BASE_URL).to_s.chomp("/")
+      raise ArgumentError, "base_url must be an http(s) URL" unless URI.parse(@base_url).is_a?(URI::HTTP)
+
+      @max_retries = max_retries
+      @timeout = timeout
+    end
+
+    # The key never shows up in logs or exception output.
+    def inspect
+      "#<#{self.class.name} mode=#{mode.inspect} base_url=#{base_url.inspect}>"
+    end
+
+    # Runs one operation. The generated resource methods call this; it is
+    # not meant for direct use.
+    # @api private
+    def execute(http_method, path, query: nil, body: nil, idempotent: false, idempotency_key: nil, model: nil)
+      check_idempotency_key(idempotency_key)
+      uri = URI.parse("#{base_url}#{path}")
+      uri.query = Util.encode_query(query) if query && !query.empty?
+      payload = body.nil? ? nil : JSON.generate(body)
+      headers = request_headers(payload, idempotent ? (idempotency_key || SecureRandom.uuid) : nil)
+
+      attempts = 0
+      loop do
+        response = perform(http_method, uri, headers, payload)
+        if response.code.to_i == 429 && attempts < max_retries
+          attempts += 1
+          sleep(retry_delay(response))
+          next
+        end
+        return handle(response, model)
+      end
+    end
+
+    private
+
+    # nil means "mint one"; a key that is present must be a real one, since
+    # an empty header would defeat the retry protection it stands for.
+    def check_idempotency_key(key)
+      return if key.nil?
+      return if key.is_a?(String) && !key.strip.empty?
+
+      raise ArgumentError, "idempotency_key must be a non-blank String"
+    end
+
+    def request_headers(payload, idempotency_key)
+      agent = "listo-ruby/#{VERSION} api/#{API_VERSION}"
+      headers = {
+        "Authorization" => "Bearer #{@api_key}",
+        "Accept" => "application/json",
+        "User-Agent" => agent,
+        "X-Listo-Client" => agent
+      }
+      headers["Content-Type"] = "application/json" if payload
+      headers["Idempotency-Key"] = idempotency_key if idempotency_key
+      headers
+    end
+
+    def perform(http_method, uri, headers, payload)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = http.read_timeout = http.write_timeout = timeout
+      has_body = !payload.nil? || %w[POST PUT PATCH].include?(http_method)
+      request = Net::HTTPGenericRequest.new(http_method, has_body, true, uri.request_uri, headers)
+      # An empty body still sends Content-Length: 0, which a POST needs.
+      request.body = payload || "" if has_body
+      http.start { |conn| conn.request(request) }
+    rescue *NETWORK_ERRORS => e
+      raise ConnectionError, "Could not reach the Listo API (#{e.class}: #{e.message})"
+    end
+
+    # Retry-After is whole seconds or an HTTP date; anything else waits a second.
+    def retry_delay(response)
+      value = response["retry-after"].to_s.strip
+      seconds =
+        if value.match?(/\A\d+\z/)
+          value.to_i
+        else
+          begin
+            Time.httpdate(value) - Time.now
+          rescue ArgumentError
+            DEFAULT_RETRY_WAIT
+          end
+        end
+      seconds.clamp(0, MAX_RETRY_WAIT)
+    end
+
+    def handle(response, model)
+      status = response.code.to_i
+      text = response.body.to_s
+      parsed = parse(text)
+      raise api_error(response, status, text, parsed) unless status.between?(200, 299)
+      return nil if status == 204 || text.strip.empty?
+      raise api_error(response, status, text, parsed) if parsed == :invalid
+
+      model ? model.build(parsed) : parsed
+    end
+
+    def parse(text)
+      return nil if text.strip.empty?
+
+      JSON.parse(text)
+    rescue JSON::ParserError
+      :invalid
+    end
+
+    def api_error(response, status, text, parsed)
+      header_id = response["x-request-id"]
+      envelope = parsed.is_a?(Hash) ? parsed["error"] : nil
+      if envelope.is_a?(Hash) && envelope["code"].is_a?(String)
+        return Error.new(
+          envelope["message"].to_s, code: envelope["code"], param: envelope["param"],
+          retryable: envelope["retryable"], status: status, request_id: envelope["request_id"] || header_id,
+          doc_url: envelope["doc_url"], body: parsed
+        )
+      end
+
+      Error.new(
+        "Unexpected response with status #{status}",
+        code: "http_#{status}", retryable: [429, 502, 503, 504].include?(status), status: status,
+        request_id: header_id, body: (parsed == :invalid || parsed.nil?) ? text : parsed
+      )
+    end
+  end
+end

data/lib/listo_delivery/errors.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ListoDelivery
+  # Raised for every non-2xx answer. The fields come from the API's `error`
+  # envelope; a body that is not that envelope (a proxy's HTML page, other
+  # JSON) still raises this class, with `code` "http_<status>".
+  class Error < StandardError
+    # @return [String, nil] the stable code to branch on, never `message`
+    attr_reader :code
+    # @return [String, nil] the request field the error is about
+    attr_reader :param
+    # @return [Boolean, nil] whether the same call may be repeated
+    attr_reader :retryable
+    # @return [Integer, nil] the HTTP status; nil when no answer arrived
+    attr_reader :status
+    # @return [String, nil] quote this when asking for support
+    attr_reader :request_id
+    # @return [String, nil] the docs page for `code`
+    attr_reader :doc_url
+    # @return [Object, nil] the parsed response body, or the raw text when it is not JSON
+    attr_reader :body
+
+    def initialize(message = nil, code: nil, param: nil, retryable: nil, status: nil, request_id: nil, doc_url: nil, body: nil)
+      super(message)
+      @code = code
+      @param = param
+      @retryable = retryable
+      @status = status
+      @request_id = request_id
+      @doc_url = doc_url
+      @body = body
+    end
+
+    def retryable?
+      retryable == true
+    end
+  end
+
+  # The request never got an answer (DNS, refused, timeout). A write may or
+  # may not have happened, so this is never retried for you.
+  class ConnectionError < Error
+    def initialize(message = nil, **rest)
+      super(message, code: "connection_error", retryable: false, **rest)
+    end
+  end
+
+  # A webhook whose signature does not verify (see Webhooks.construct_event).
+  class SignatureError < Error
+    def initialize(message = "The webhook signature does not match.", **rest)
+      super(message, code: "invalid_signature", retryable: false, **rest)
+    end
+  end
+end

data/lib/listo_delivery/generated/api_version.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# GENERATED from Listo's API definition (API 1.37.0). Do not edit by hand:
+# this file is rewritten whenever the SDK is regenerated.
+
+module ListoDelivery
+  # The API release this SDK was generated from (the schema's info.version).
+  API_VERSION = "1.37.0"
+
+  # The schema's first server.
+  DEFAULT_BASE_URL = "https://api.listo.delivery"
+end

data/lib/listo_delivery/generated/client_operations.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# GENERATED from Listo's API definition (API 1.37.0). Do not edit by hand:
+# this file is rewritten whenever the SDK is regenerated.
+
+module ListoDelivery
+  # The resource readers and the root operations of Client, from Listo's API definition.
+  module ClientOperations
+    # @return [Resources::Balance]
+    def balance
+      @balance ||= Resources::Balance.new(self)
+    end
+
+    # @return [Resources::CardOnboarding]
+    def card_onboarding
+      @card_onboarding ||= Resources::CardOnboarding.new(self)
+    end
+
+    # @return [Resources::ConnectRequests]
+    def connect_requests
+      @connect_requests ||= Resources::ConnectRequests.new(self)
+    end
+
+    # @return [Resources::Connections]
+    def connections
+      @connections ||= Resources::Connections.new(self)
+    end
+
+    # @return [Resources::Deliveries]
+    def deliveries
+      @deliveries ||= Resources::Deliveries.new(self)
+    end
+
+    # @return [Resources::Events]
+    def events
+      @events ||= Resources::Events.new(self)
+    end
+
+    # @return [Resources::Ledger]
+    def ledger
+      @ledger ||= Resources::Ledger.new(self)
+    end
+
+    # @return [Resources::Quotes]
+    def quotes
+      @quotes ||= Resources::Quotes.new(self)
+    end
+
+    # @return [Resources::RequestLogs]
+    def request_logs
+      @request_logs ||= Resources::RequestLogs.new(self)
+    end
+
+    # @return [Resources::Stores]
+    def stores
+      @stores ||= Resources::Stores.new(self)
+    end
+
+    # @return [Resources::Webhooks]
+    def webhooks
+      @webhooks ||= Resources::Webhooks.new(self)
+    end
+
+    # @return [Resources::Withdrawals]
+    def withdrawals
+      @withdrawals ||= Resources::Withdrawals.new(self)
+    end
+
+    # Check that your API key works.
+    #
+    # GET /v1/ping
+    # @return [Models::Ping]
+    # @raise [ListoDelivery::Error]
+    def ping
+      execute(
+        "GET",
+        "/v1/ping",
+        model: Models::Ping
+      )
+    end
+  end
+end

data/lib/listo_delivery/generated/loader.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# GENERATED from Listo's API definition (API 1.37.0). Do not edit by hand:
+# this file is rewritten whenever the SDK is regenerated.
+
+require_relative "api_version"
+require_relative "models/webhook_event"
+require_relative "models/balance"
+require_relative "models/cancel_delivery_request"
+require_relative "models/card_onboarding_link"
+require_relative "models/card_status"
+require_relative "models/connect_request"
+require_relative "models/courier_ping"
+require_relative "models/create_connect_request_request"
+require_relative "models/create_connection_request"
+require_relative "models/create_delivery_request"
+require_relative "models/create_quote_request"
+require_relative "models/create_store_owner_request"
+require_relative "models/create_store_request"
+require_relative "models/create_withdrawal_request"
+require_relative "models/delivery"
+require_relative "models/delivery_courier_location_event"
+require_relative "models/delivery_list"
+require_relative "models/delivery_message_skipped"
+require_relative "models/delivery_message_skipped_event"
+require_relative "models/delivery_status_changed_event"
+require_relative "models/delivery_updated_event"
+require_relative "models/error"
+require_relative "models/error_response"
+require_relative "models/event_list"
+require_relative "models/ledger_entry"
+require_relative "models/ledger_entry_list"
+require_relative "models/manifest"
+require_relative "models/manifest_item"
+require_relative "models/owner_invitation"
+require_relative "models/ping"
+require_relative "models/quote"
+require_relative "models/refund_delivery_request"
+require_relative "models/request_log"
+require_relative "models/request_log_detail"
+require_relative "models/request_log_list"
+require_relative "models/reschedule_delivery_request"
+require_relative "models/same_day_terms"
+require_relative "models/send_test_webhook_request"
+require_relative "models/store"
+require_relative "models/store_balance"
+require_relative "models/store_connected_event"
+require_relative "models/store_list"
+require_relative "models/store_updated_event"
+require_relative "models/update_store_request"
+require_relative "models/webhook_delivery"
+require_relative "models/webhook_delivery_list"
+require_relative "models/webhook_event_envelope"
+require_relative "models/withdrawal"
+require_relative "models/withdrawal_list"
+require_relative "models/withdrawal_updated_event"
+require_relative "resources/balance"
+require_relative "resources/card_onboarding"
+require_relative "resources/connect_requests"
+require_relative "resources/connections"
+require_relative "resources/deliveries"
+require_relative "resources/events"
+require_relative "resources/ledger"
+require_relative "resources/quotes"
+require_relative "resources/request_logs"
+require_relative "resources/stores"
+require_relative "resources/webhooks"
+require_relative "resources/withdrawals"
+require_relative "client_operations"

data/lib/listo_delivery/generated/models/balance.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# GENERATED from Listo's API definition (API 1.37.0). Do not edit by hand:
+# this file is rewritten whenever the SDK is regenerated.
+
+module ListoDelivery
+  module Models
+    # Your prepaid balance for the world the key acts in.
+    class Balance < Model
+      TYPES = {
+        "balance_cents" => nil,
+        "available_cents" => nil,
+        "currency" => nil,
+        "same_day" => ["model", "SameDayTerms"],
+        "in_review_cents" => nil
+      }.freeze
+
+      # Everything in the account, in centavos.
+      # @return [Integer]
+      def balance_cents
+        read("balance_cents")
+      end
+
+      # What you can withdraw today.
+      # @return [Integer]
+      def available_cents
+        read("available_cents")
+      end
+
+      # One of: "MXN".
+      # @return [String]
+      def currency
+        read("currency")
+      end
+
+      # @return [Models::SameDayTerms]
+      def same_day
+        read("same_day")
+      end
+
+      # The part of `balance_cents` that is cash from an order we are still reviewing.
+      # @return [Integer]
+      def in_review_cents
+        read("in_review_cents")
+      end
+    end
+  end
+end

data/lib/listo_delivery/generated/models/cancel_delivery_request.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# GENERATED from Listo's API definition (API 1.37.0). Do not edit by hand:
+# this file is rewritten whenever the SDK is regenerated.
+
+module ListoDelivery
+  module Models
+    # Why the order is being canceled.
+    class CancelDeliveryRequest < Model
+      TYPES = {
+        "reason" => nil,
+        "description" => nil
+      }.freeze
+
+      # Why the order is canceled.
+      # One of: "customer_canceled", "store_closed", "item_unavailable", "wrong_address", "no_longer_needed", "other".
+      # @return [String]
+      def reason
+        read("reason")
+      end
+
+      # A sentence of explanation.
+      # @return [String, nil]
+      def description
+        read("description")
+      end
+    end
+  end
+end

data/lib/listo_delivery/generated/models/card_onboarding_link.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# GENERATED from Listo's API definition (API 1.37.0). Do not edit by hand:
+# this file is rewritten whenever the SDK is regenerated.
+
+module ListoDelivery
+  module Models
+    # A one-time hosted link to complete card onboarding.
+    class CardOnboardingLink < Model
+      TYPES = {
+        "url" => nil
+      }.freeze
+
+      # Send this to whoever can answer for the business.
+      # @return [String]
+      def url
+        read("url")
+      end
+    end
+  end
+end