payment_kit 1.0.0

data/lib/payment_kit/errors.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "json"
+
+module PaymentKit
+  # Base error for all PaymentKit failures.
+  #
+  # PaymentKit returns RFC 7807 problem documents. Standard members (+title+,
+  # +detail+, +status+, +instance+, +request_id+) plus any extension members are
+  # kept in +problem+ so callers can branch on them without re-parsing the body.
+  #
+  # Transient failures carry a top-level +error_code+ and +retryable: true+
+  # (for example +invoice_locked+ on HTTP 409).
+  class Error < StandardError
+    # HTTP status of the failing response, or +nil+ for client-side failures.
+    attr_reader :status
+
+    # Raw response body as received.
+    attr_reader :body
+
+    # PaymentKit request id, from the problem document or the +Request-Id+ header.
+    attr_reader :request_id
+
+    # Machine-readable code such as +invoice_locked+, when PaymentKit sends one.
+    attr_reader :error_code
+
+    # Parsed RFC 7807 problem document as a Hash; empty when the body was not JSON.
+    attr_reader :problem
+
+    # Any attribute not passed explicitly is read from the RFC 7807 +body+.
+    def initialize(message = nil, status: nil, body: nil, request_id: nil,
+                   error_code: nil, retryable: nil)
+      @status = status
+      @body = body
+      @problem = parse_problem(body)
+      @request_id = request_id || @problem["request_id"]
+      @error_code = error_code || @problem["error_code"]
+      @retryable = retryable.nil? ? @problem["retryable"] : retryable
+      super(message)
+    end
+
+    # Whether PaymentKit marked this failure as safe to retry unchanged.
+    def retryable?
+      @retryable == true
+    end
+
+    # Reads an RFC 7807 extension member, e.g. +error["invoice_id"]+.
+    def [](key)
+      @problem[key.to_s]
+    end
+
+    # Convenience reader for the +invoice_id+ extension member, when present.
+    def invoice_id
+      self["invoice_id"]
+    end
+
+    # Convenience reader for the +subscription_id+ extension member, when present.
+    def subscription_id
+      self["subscription_id"]
+    end
+
+    private
+
+    def parse_problem(raw)
+      return {} if raw.nil? || raw.to_s.empty?
+
+      parsed = JSON.parse(raw.to_s)
+      parsed.is_a?(Hash) ? parsed : {}
+    rescue JSON::ParserError
+      {}
+    end
+  end
+
+  # Raised when credentials are missing/invalid or the API returns 401.
+  class AuthenticationError < Error; end
+
+  # Raised on HTTP 403: the credential is valid but is not allowed to touch this
+  # resource. Subclasses AuthenticationError so existing rescues still match.
+  class PermissionError < AuthenticationError; end
+
+  # Raised when an inbound webhook signature is missing or does not verify.
+  # Subclasses AuthenticationError so existing rescues still match.
+  class SignatureVerificationError < AuthenticationError; end
+
+  # Raised for client-side invalid parameters or API 400/404/422 responses.
+  class InvalidRequestError < Error; end
+
+  # Raised when a request conflicts with the current resource state (HTTP 409).
+  class ConflictError < Error; end
+
+  # Raised when a payment attempt is declined (HTTP 402). The invoice or intent
+  # is left in a retry-safe state, so this is a decline rather than a bug.
+  class CardError < Error; end
+
+  # Raised when the API rate-limits the client (HTTP 429).
+  class RateLimitError < Error; end
+
+  # Raised for unexpected API responses and other HTTP error statuses.
+  class APIError < Error; end
+
+  # Raised when the HTTP connection fails (timeouts, refused, reset, etc.).
+  class APIConnectionError < Error; end
+end

data/lib/payment_kit/instrumentation.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module PaymentKit
+  # Optional hooks around outbound HTTP requests.
+  #
+  # Deliberately separate from the webhook event bus: instrumenting API calls
+  # through +ActiveSupport::Notifications+ under the +payment_kit.+ namespace
+  # would deliver them to +PaymentKit.all+ webhook subscribers.
+  #
+  #   PaymentKit::Instrumentation.subscribe(:request_end) do |event|
+  #     StatsD.timing("payment_kit.request", event.duration * 1000,
+  #                   tags: ["path:#{event.path}", "status:#{event.status}"])
+  #   end
+  #
+  # Subscriber exceptions are never allowed to break the API call.
+  module Instrumentation
+    # Emitted before the request leaves the process.
+    class RequestBeginEvent
+      # HTTP verb as a Symbol, e.g. +:post+.
+      attr_reader :method
+
+      # Request path, relative to the account base URL.
+      attr_reader :path
+
+      def initialize(method:, path:) # :nodoc:
+        @method = method
+        @path = path
+      end
+    end
+
+    # Emitted once a request has finished, including after retries.
+    class RequestEvent
+      # HTTP verb as a Symbol, e.g. +:post+.
+      attr_reader :method
+
+      # Request path, relative to the account base URL.
+      attr_reader :path
+
+      # HTTP status of the final attempt, or +nil+ if no response arrived.
+      attr_reader :status
+
+      # Wall-clock seconds for the whole call, retries included.
+      attr_reader :duration
+
+      # Number of retries performed; +0+ when the first attempt settled it.
+      attr_reader :num_retries
+
+      # PaymentKit request id from the response headers, when present.
+      attr_reader :request_id
+
+      def initialize(method:, path:, status:, duration:, num_retries:, request_id: nil) # :nodoc:
+        @method = method
+        @path = path
+        @status = status
+        @duration = duration
+        @num_retries = num_retries
+        @request_id = request_id
+      end
+    end
+
+    # Topics that may be subscribed to.
+    TOPICS = %i[request_begin request_end].freeze
+
+    class << self
+      # Registered blocks, keyed by topic and then by subscriber name.
+      def subscribers
+        @subscribers ||= Hash.new { |hash, key| hash[key] = {} }
+      end
+
+      # Registers +block+ for +topic+, which must be +:request_begin+ or
+      # +:request_end+. Returns the subscriber name, for use with #unsubscribe.
+      def subscribe(topic, name = SecureRandom.uuid, &block)
+        raise ArgumentError, "unknown topic: #{topic}" unless TOPICS.include?(topic)
+        raise ArgumentError, "subscriber block required" if block.nil?
+
+        subscribers[topic][name] = block
+        name
+      end
+
+      # Removes the subscriber registered under +name+ for +topic+.
+      def unsubscribe(topic, name)
+        subscribers[topic].delete(name)
+      end
+
+      # Whether +topic+ has any subscribers. The client checks this before
+      # building event objects, so an unsubscribed topic costs nothing.
+      def subscribers?(topic)
+        !subscribers[topic].empty?
+      end
+
+      # Notifies subscribers. A raising subscriber must never break the API call,
+      # so failures are swallowed after being reported to +$stderr+.
+      def notify(topic, event)
+        subscribers[topic].each_value do |subscriber|
+          subscriber.call(event)
+        rescue StandardError => e
+          warn("[PaymentKit::Instrumentation] #{topic} subscriber raised: #{e.message}")
+        end
+      end
+
+      # Drops every subscriber. Intended for test suites.
+      def reset!
+        @subscribers = nil
+      end
+    end
+  end
+end

data/lib/payment_kit/namespace.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module PaymentKit
+  # Prefixes notification names and builds subscription regexes.
+  #
+  # Events instrument as +payment_kit.<type>+.
+  class Namespace
+    # +prefix+ is prepended to every event type, and should end with a dot.
+    def initialize(prefix)
+      @prefix = prefix.to_s
+    end
+
+    # The configured prefix, e.g. <tt>"payment_kit."</tt>.
+    attr_reader :prefix
+
+    # Returns the fully namespaced notification name for an event type.
+    def call(name)
+      "#{@prefix}#{name}"
+    end
+
+    # +nil+/empty name matches the entire namespace (used by +PaymentKit.all+).
+    def to_regexp(name = nil)
+      pattern = name.nil? || name.to_s.empty? ? @prefix : "#{@prefix}#{name}"
+      /\A#{Regexp.escape(pattern)}/
+    end
+  end
+end

data/lib/payment_kit/notification_adapter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module PaymentKit
+  # Adapts ActiveSupport::Notifications' multi-argument callback to +#call(event)+.
+  class NotificationAdapter
+    # Wraps +subscriber+ so the notification backend can invoke it.
+    def self.call(subscriber)
+      new(subscriber)
+    end
+
+    def initialize(subscriber) # :nodoc:
+      @subscriber = subscriber
+    end
+
+    # Receives the backend's callback arguments and forwards only the payload.
+    def call(*args)
+      event = args.last
+      @subscriber.call(event)
+    end
+  end
+end

data/lib/payment_kit/resources/catalog.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module PaymentKit
+  module Resources
+    # Products and prices.
+    module Catalog
+      # GET /products/ — auto-paginated Array of products.
+      def list_products(params = {}) = list("/products/", params)
+
+      # GET /products/{id}
+      def retrieve_product(id) = get("/products/#{id}")
+
+      # POST /products/ — takes +name+, +description+, +is_active+,
+      # +default_price_id+, +metadata+, +custom_fields+.
+      def create_product(params = nil, **) = post("/products/", params, **)
+
+      # PATCH /products/{id} — only the fields you send are changed.
+      def update_product(id, params = nil, **) = patch("/products/#{id}", params, **)
+
+      # GET /products/{id}/prices — auto-paginated Array of the product's prices.
+      def list_product_prices(product_id, params = {})
+        list("/products/#{product_id}/prices", params)
+      end
+
+      # GET /prices/ — auto-paginated Array of prices.
+      def list_prices(params = {}) = list("/prices/", params)
+
+      # GET /prices/{id}
+      def retrieve_price(id, params = {}) = get("/prices/#{id}", params)
+
+      # POST /prices/ — takes +product_id+, +currency+, +unit_amount_atom+,
+      # +pricing_type+, +billing_scheme+, +recurring_interval+ and friends.
+      def create_price(params = nil, **) = post("/prices/", params, **)
+    end
+  end
+end

data/lib/payment_kit/resources/customers.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module PaymentKit
+  # Endpoint methods, grouped by resource and mixed into PaymentKit::Client.
+  #
+  # Each module assumes the private request helpers the client provides, so the
+  # modules are not useful on their own.
+  module Resources
+    # Customers, credit balance and credit notes.
+    #
+    # Write methods accept the body positionally or as keywords, and take an
+    # optional +idempotency_key:+:
+    #
+    #   client.create_customer(email: "a@b.com")
+    #   client.create_customer({ email: "a@b.com" }, idempotency_key: "signup-42")
+    module Customers
+      # POST /customers/ — takes +email+, +first_name+, +last_name+,
+      # +business_name+, +address+, +currency+, +metadata+ and friends.
+      def create_customer(params = nil, **) = post("/customers/", params, **)
+
+      # GET /customers/{id}
+      def retrieve_customer(id) = get("/customers/#{id}")
+
+      # PUT /customers/{id} — only the fields you send are changed.
+      def update_customer(id, params = nil, **) = put("/customers/#{id}", params, **)
+
+      # GET /customers/ — auto-paginated Array of customers.
+      def list_customers(params = {}) = list("/customers/", params)
+
+      # Sets the customer's credit balance to an ABSOLUTE target for the given
+      # currency — PaymentKit issues or voids credit to reach it. This is not a
+      # delta; use #create_credit_note to add credit incrementally.
+      #
+      #   client.set_credit_balance("cus_1", amount_atom: 5000, currency: "USD")
+      def set_credit_balance(customer_id, params = nil, **)
+        patch("/customers/#{customer_id}/credit-balance", params, **)
+      end
+
+      # *Deprecated.* Use #set_credit_balance. The name implied delta semantics,
+      # but the endpoint sets an absolute target balance.
+      def create_balance_transaction(customer_id, params = nil, **)
+        warn("[PaymentKit] create_balance_transaction is deprecated; use set_credit_balance. " \
+             "The endpoint sets an absolute target balance, not a delta.")
+        set_credit_balance(customer_id, params, **)
+      end
+
+      # Appends a credit note (an additive adjustment) to the customer balance.
+      # Always pass a stable +idempotency_key+: a double submit issues two notes.
+      #
+      # +reason+ is required and must be one of +proration_excess+,
+      # +manual_adjustment+, +auto_apply+ or +debit_settlement+.
+      def create_credit_note(customer_id, params = nil, **)
+        post("/customers/#{customer_id}/credit-notes", params, **)
+      end
+
+      # GET /customers/{id}/credit-notes — newest first; filter with +currency+.
+      def list_credit_notes(customer_id, params = {})
+        list("/customers/#{customer_id}/credit-notes", params)
+      end
+    end
+  end
+end

data/lib/payment_kit/resources/invoices.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module PaymentKit
+  module Resources
+    # Invoices and floating (pending) invoice items.
+    module Invoices
+      # POST /invoices/ — creates a one-off invoice in +draft+. Each entry in
+      # +items+ takes an +amount+, a +unit_amount+ with +quantity+, or a
+      # catalog +price_id+.
+      def create_invoice(params = nil, **) = post("/invoices/", params, **)
+
+      # Supports +expand+, e.g. <tt>retrieve_invoice("in_1", expand: "custom_fields")</tt>.
+      def retrieve_invoice(id, params = {}) = get("/invoices/#{id}", params)
+
+      # GET /invoices/ — auto-paginated Array of invoices.
+      def list_invoices(params = {}) = list("/invoices/", params)
+
+      # Returns <tt>{ "pdf_url" => ..., "status" => "available" | "generating" }</tt>;
+      # poll again while +status+ is +generating+.
+      def retrieve_invoice_pdf(id) = get("/invoices/#{id}/pdf")
+
+      # Attempts collection on an open invoice (finalizing it first if draft).
+      # A decline raises PaymentKit::CardError and leaves the invoice payable.
+      def pay_invoice(id, params = nil, **) = post("/invoices/#{id}/collect", params, **)
+
+      # Cancels the invoice so no payment is expected.
+      def void_invoice(id, **) = post("/invoices/#{id}/void", {}, **)
+
+      # Moves a draft invoice to +open+ and locks its amounts.
+      def finalize_invoice(id, **) = post("/invoices/#{id}/finalize", {}, **)
+
+      # Only permitted from +OPEN+ or +PAST_DUE+; other states return 422.
+      def mark_invoice_uncollectible(id, **)
+        post("/invoices/#{id}/mark-uncollectible", {}, **)
+      end
+
+      # Sweeps floating items into standalone invoices (one per currency),
+      # finalizes them and attempts collection. Always pass a stable
+      # +idempotency_key+ or duplicate requests create duplicate invoices.
+      def bill_pending_items(params = nil, **)
+        post("/invoices/bill-pending-items", params, **)
+      end
+
+      # --- Invoice items ------------------------------------------------------
+
+      # POST /invoice-items/ — creates a floating (pending) item, collected at
+      # the next renewal or on demand via #bill_pending_items. The subscription
+      # must be +active+ or +trialing+ and belong to the same customer.
+      def create_invoice_item(params = nil, **) = post("/invoice-items/", params, **)
+
+      # GET /invoice-items/{id}
+      def retrieve_invoice_item(id) = get("/invoice-items/#{id}")
+
+      # GET /invoice-items/ — auto-paginated; filter with +subscription_id+ and
+      # <tt>status: "floating"</tt> to list pending items.
+      def list_invoice_items(params = {}) = list("/invoice-items/", params)
+
+      # PATCH /invoice-items/{id}
+      def update_invoice_item(id, params = nil, **)
+        patch("/invoice-items/#{id}", params, **)
+      end
+    end
+  end
+end

data/lib/payment_kit/resources/payments.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module PaymentKit
+  module Resources
+    # Payment intents, payment methods, refunds and checkout sessions.
+    module Payments
+      # --- Payment intents ----------------------------------------------------
+
+      # POST /payments/intents/ — takes +customer_id+, +amount_atom+,
+      # +currency+, +payment_method_id+, +processor_id+ and +metadata+.
+      def create_payment_intent(params = nil, **)
+        post("/payments/intents/", params, **)
+      end
+
+      # Supports <tt>expand: "checkout_attempt"</tt>.
+      def retrieve_payment_intent(id, params = {}) = get("/payments/intents/#{id}", params)
+
+      # GET /payments/intents/ — auto-paginated Array of payment intents.
+      def list_payment_intents(params = {}) = list("/payments/intents/", params)
+
+      # Auto-paginated Array of refunds recorded against a payment intent.
+      def list_refunds_by_intent(payment_intent_id, params = {})
+        list("/payments/refunds/by_intent/#{payment_intent_id}", params)
+      end
+
+      # Auto-paginated Array of processor attempts for a payment intent.
+      def list_attempts_by_intent(payment_intent_id, params = {})
+        list("/payments/processor_attempts/by_intent/#{payment_intent_id}", params)
+      end
+
+      # --- Payment methods ----------------------------------------------------
+
+      # POST /payments/payment_methods/
+      def create_payment_method(params = nil, **)
+        post("/payments/payment_methods/", params, **)
+      end
+
+      # GET /payments/payment_methods/{id}
+      def retrieve_payment_method(id) = get("/payments/payment_methods/#{id}")
+
+      # PUT /payments/payment_methods/{id}
+      def update_payment_method(id, params = nil, **)
+        put("/payments/payment_methods/#{id}", params, **)
+      end
+
+      # Documented way to take a card out of use: flips +is_active+ to false.
+      # Prefer this over #detach_payment_method.
+      def deactivate_payment_method(id) = update_payment_method(id, is_active: false)
+
+      # Removes the payment method outright.
+      #
+      # NOTE: PaymentKit documents deletion only on the customer-portal surface
+      # (<tt>DELETE /billing-portal/token/{token}/payment-methods/{id}</tt>). This
+      # account-scoped delete is kept for backwards compatibility; if your account
+      # returns 404/405, use #deactivate_payment_method instead.
+      def detach_payment_method(id) = delete("/payments/payment_methods/#{id}")
+
+      # --- Checkout sessions --------------------------------------------------
+
+      # Returns a session carrying the +secure_token+ used to initialise
+      # PaymentKit.js or redirect to hosted checkout. +line_items+,
+      # +success_url+ and +return_url+ are required.
+      def create_checkout_session(params = nil, **)
+        post("/checkout-sessions", params, **)
+      end
+
+      # GET /checkout-sessions/{id}
+      def retrieve_checkout_session(id) = get("/checkout-sessions/#{id}")
+    end
+  end
+end

data/lib/payment_kit/resources/subscriptions.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module PaymentKit
+  module Resources
+    # Subscription lifecycle, scheduling and change requests.
+    module Subscriptions
+      # POST /subscriptions — +customer_id+, +currency+, +billing_interval+,
+      # +billing_interval_count+, +period_start+ and +collection_method+ are
+      # required; +items+ is an Array of +price_id+/+quantity+ pairs.
+      def create_subscription(params = nil, **) = post("/subscriptions", params, **)
+
+      # GET /subscriptions/{id}
+      def retrieve_subscription(id) = get("/subscriptions/#{id}")
+
+      # GET /subscriptions — auto-paginated Array of subscriptions.
+      def list_subscriptions(params = {}) = list("/subscriptions", params)
+
+      # PATCH /subscriptions/{id} — subscription-level fields such as
+      # +cancel_at_period_end+ and +metadata+. Line items are not accepted here;
+      # use #update_subscription_items.
+      def update_subscription(id, params = nil, **)
+        patch("/subscriptions/#{id}", params, **)
+      end
+
+      # Add/update/remove items within the current billing interval. Charge-first:
+      # payment is collected before the change applies, so pass a stable
+      # +idempotency_key+. +proration_behavior+ is required by the API.
+      def update_subscription_items(id, params = nil, **)
+        patch("/subscriptions/#{id}/items", params, **)
+      end
+
+      # Immediate, irreversible cancellation. Accepts +refund_option+
+      # (+none+, +full+, +prorated+, +cancel_unpaid+) and +is_preview+.
+      def cancel_subscription(id, params = nil, **)
+        post("/subscriptions/#{id}/cancel", params, **)
+      end
+
+      # Cancel on a specific date instead of immediately.
+      def schedule_cancellation(id, params = nil, **)
+        post("/subscriptions/#{id}/schedule-cancellation", params, **)
+      end
+
+      # Clears a cancellation previously scheduled by #schedule_cancellation.
+      def cancel_scheduled_cancellation(id) = delete("/subscriptions/#{id}/scheduled-cancellation")
+
+      # +pause_behavior+ (+pause_immediately+/+pause_at_end+) is required.
+      def pause_subscription(id, params = nil, **)
+        post("/subscriptions/#{id}/pause", params, **)
+      end
+
+      # Removes a pending +pause_at_end+ before it activates.
+      def cancel_scheduled_pause(id) = delete("/subscriptions/#{id}/scheduled-pause")
+
+      # Resumes a paused subscription. Whether billing re-anchors or catches up
+      # is governed by the account's +resume_billing_behavior+ setting.
+      def resume_subscription(id, params = nil, **)
+        post("/subscriptions/#{id}/resume", params, **)
+      end
+
+      # Moves the next invoice date. Accepts +next_billing_date+,
+      # +create_proration+ and +is_preview+.
+      def reschedule_billing(id, params = nil, **)
+        post("/subscriptions/#{id}/reschedule-billing", params, **)
+      end
+
+      # Forces a renewal cycle immediately.
+      def renew_subscription(id, **) = post("/subscriptions/#{id}/renew", {}, **)
+
+      # *Deprecated.* PaymentKit documents +change-plan+ as the legacy
+      # single-call endpoint, planned for deprecation. Prefer the change-request
+      # workflow (#create_change_request, #add_change_request_changes,
+      # #preview_change_request, #apply_change_request) or the one-step
+      # #apply_subscription_changes.
+      def change_plan(subscription_id, params = nil, **)
+        post("/subscriptions/#{subscription_id}/change-plan", params, **)
+      end
+
+      # Cancels a scheduled (period-end) plan change before it executes.
+      def cancel_pending_change(id) = delete("/subscriptions/#{id}/pending-change")
+
+      # --- Change requests ----------------------------------------------------
+
+      # Opens a draft change request. Accepts +reason+ and +expires_in_hours+.
+      #
+      # Only one active (draft/ready) change request may exist per subscription;
+      # creating a second raises ConflictError (HTTP 409).
+      def create_change_request(subscription_id, params = nil, **)
+        post("/subscriptions/#{subscription_id}/change-requests", params, **)
+      end
+
+      # GET /subscriptions/{id}/change-requests/{request_id}
+      def retrieve_change_request(subscription_id, request_id)
+        get("/subscriptions/#{subscription_id}/change-requests/#{request_id}")
+      end
+
+      # Returns +null+ when the subscription has no active change request.
+      def active_change_request(subscription_id)
+        get("/subscriptions/#{subscription_id}/change-requests/active")
+      end
+
+      # Appends +item_changes+, +coupon_changes+, +balance_changes+ and
+      # +trial_behavior+ to a draft. Callable repeatedly; each call appends.
+      # Adding changes to a +ready+ request reverts it to +draft+.
+      def add_change_request_changes(subscription_id, request_id, params = nil, **)
+        patch("/subscriptions/#{subscription_id}/change-requests/#{request_id}", params, **)
+      end
+
+      # Computes proration and moves the request to +ready+.
+      def preview_change_request(subscription_id, request_id)
+        post("/subscriptions/#{subscription_id}/change-requests/#{request_id}/preview", {})
+      end
+
+      # Charge-first execution: pass a stable +idempotency_key+.
+      def apply_change_request(subscription_id, request_id, **)
+        post("/subscriptions/#{subscription_id}/change-requests/#{request_id}/apply", {}, **)
+      end
+
+      # Discards a change request without applying it.
+      def cancel_change_request(subscription_id, request_id)
+        delete("/subscriptions/#{subscription_id}/change-requests/#{request_id}")
+      end
+
+      # One-step shortcut: create, add changes, preview and apply in a single call.
+      def apply_subscription_changes(subscription_id, params = nil, **)
+        post("/subscriptions/#{subscription_id}/change-requests/apply", params, **)
+      end
+    end
+  end
+end

data/lib/payment_kit/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module PaymentKit
+  # Gem version.
+  VERSION = "1.0.0"
+end