lithic 0.1.0.pre.alpha.1

data/lib/lithic/resources/aggregate_balances.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Lithic
+  module Resources
+    class AggregateBalances
+      # Get the aggregated balance across all end-user accounts by financial account
+      #   type
+      #
+      # @param params [Lithic::Models::AggregateBalanceListParams, Hash{Symbol=>Object}] .
+      #
+      #   @option params [Symbol, Lithic::Models::AggregateBalanceListParams::FinancialAccountType] :financial_account_type Get the aggregate balance for a given Financial Account type.
+      #
+      #   @option params [Lithic::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+      #
+      # @return [Lithic::SinglePage<Lithic::Models::AggregateBalance>]
+      def list(params = {})
+        parsed, options = Lithic::Models::AggregateBalanceListParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "v1/aggregate_balances",
+          query: parsed,
+          page: Lithic::SinglePage,
+          model: Lithic::Models::AggregateBalance,
+          options: options
+        )
+      end
+
+      # @param client [Lithic::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/lithic/resources/auth_rules/v2/backtests.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Lithic
+  module Resources
+    class AuthRules
+      class V2
+        class Backtests
+          # Initiates a request to asynchronously generate a backtest for an authorization
+          #   rule. During backtesting, both the active version (if one exists) and the draft
+          #   version of the Authorization Rule are evaluated by replaying historical
+          #   transaction data against the rule's conditions. This process allows customers to
+          #   simulate and understand the effects of proposed rule changes before deployment.
+          #   The generated backtest report provides detailed results showing whether the
+          #   draft version of the Auth Rule would have approved or declined historical
+          #   transactions which were processed during the backtest period. These reports help
+          #   evaluate how changes to rule configurations might affect overall transaction
+          #   approval rates.
+          #
+          #   The generated backtest report will be delivered asynchronously through a webhook
+          #   with `event_type` = `auth_rules.backtest_report.created`. See the docs on
+          #   setting up [webhook subscriptions](https://docs.lithic.com/docs/events-api). It
+          #   is also possible to request backtest reports on-demand through the
+          #   `/v2/auth_rules/{auth_rule_token}/backtests/{auth_rule_backtest_token}`
+          #   endpoint.
+          #
+          #   Lithic currently supports backtesting for `CONDITIONAL_BLOCK` rules. Backtesting
+          #   for `VELOCITY_LIMIT` rules is generally not supported. In specific cases (i.e.
+          #   where Lithic has pre-calculated the requested velocity metrics for historical
+          #   transactions), a backtest may be feasible. However, such cases are uncommon and
+          #   customers should not anticipate support for velocity backtests under most
+          #   configurations. If a historical transaction does not feature the required inputs
+          #   to evaluate the rule, then it will not be included in the final backtest report.
+          #
+          # @param auth_rule_token [String] Globally unique identifier for the Auth Rule.
+          #
+          # @param params [Lithic::Models::AuthRules::V2::BacktestCreateParams, Hash{Symbol=>Object}] .
+          #
+          #   @option params [Time] :end_ The end time of the backtest.
+          #
+          #   @option params [Time] :start The start time of the backtest.
+          #
+          #   @option params [Lithic::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+          #
+          # @return [Lithic::Models::AuthRules::V2::BacktestCreateResponse]
+          def create(auth_rule_token, params = {})
+            parsed, options = Lithic::Models::AuthRules::V2::BacktestCreateParams.dump_request(params)
+            @client.request(
+              method: :post,
+              path: ["v2/auth_rules/%0s/backtests", auth_rule_token],
+              body: parsed,
+              model: Lithic::Models::AuthRules::V2::BacktestCreateResponse,
+              options: options
+            )
+          end
+
+          # Returns the backtest results of an authorization rule (if available).
+          #
+          #   Backtesting is an asynchronous process that requires time to complete. If a
+          #   customer retrieves the backtest results using this endpoint before the report is
+          #   fully generated, the response will return null for `results.current_version` and
+          #   `results.draft_version`. Customers are advised to wait for the backtest creation
+          #   process to complete (as indicated by the webhook event
+          #   auth_rules.backtest_report.created) before retrieving results from this
+          #   endpoint.
+          #
+          #   Backtesting is an asynchronous process, while the backtest is being processed,
+          #   results will not be available which will cause `results.current_version` and
+          #   `results.draft_version` objects to contain `null`. The entries in `results` will
+          #   also always represent the configuration of the rule at the time requests are
+          #   made to this endpoint. For example, the results for `current_version` in the
+          #   served backtest report will be consistent with which version of the rule is
+          #   currently activated in the Auth Stream, regardless of which version of the rule
+          #   was active in the Auth Stream at the time a backtest is requested.
+          #
+          # @param auth_rule_backtest_token [String] Globally unique identifier for an Auth Rule backtest.
+          #
+          # @param params [Lithic::Models::AuthRules::V2::BacktestRetrieveParams, Hash{Symbol=>Object}] .
+          #
+          #   @option params [String] :auth_rule_token Globally unique identifier for the Auth Rule.
+          #
+          #   @option params [Lithic::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+          #
+          # @return [Lithic::Models::AuthRules::V2::BacktestResults]
+          def retrieve(auth_rule_backtest_token, params)
+            parsed, options = Lithic::Models::AuthRules::V2::BacktestRetrieveParams.dump_request(params)
+            auth_rule_token =
+              parsed.delete(:auth_rule_token) do
+                raise ArgumentError.new("missing required path argument #{_1}")
+              end
+            @client.request(
+              method: :get,
+              path: ["v2/auth_rules/%0s/backtests/%1s", auth_rule_token, auth_rule_backtest_token],
+              model: Lithic::Models::AuthRules::V2::BacktestResults,
+              options: options
+            )
+          end
+
+          # @param client [Lithic::Client]
+          def initialize(client:)
+            @client = client
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lithic/resources/auth_rules/v2.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+module Lithic
+  module Resources
+    class AuthRules
+      class V2
+        # @return [Lithic::Resources::AuthRules::V2::Backtests]
+        attr_reader :backtests
+
+        # Creates a new V2 authorization rule in draft mode
+        #
+        # @param params [Lithic::Models::AuthRules::V2CreateParams, Hash{Symbol=>Object}] .
+        #
+        #   @option params [Array<String>] :account_tokens Account tokens to which the Auth Rule applies.
+        #
+        #   @option params [Array<String>] :card_tokens Card tokens to which the Auth Rule applies.
+        #
+        #   @option params [Boolean] :program_level Whether the Auth Rule applies to all authorizations on the card program.
+        #
+        #   @option params [String, nil] :name Auth Rule Name
+        #
+        #   @option params [Lithic::Models::AuthRules::ConditionalBlockParameters, Lithic::Models::AuthRules::VelocityLimitParams] :parameters Parameters for the Auth Rule
+        #
+        #   @option params [Symbol, Lithic::Models::AuthRules::V2CreateParams::Type] :type The type of Auth Rule
+        #
+        #   @option params [Array<String>] :excluded_card_tokens Card tokens to which the Auth Rule does not apply.
+        #
+        #   @option params [Lithic::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+        #
+        # @return [Lithic::Models::AuthRules::V2CreateResponse]
+        def create(params)
+          parsed, options = Lithic::Models::AuthRules::V2CreateParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: "v2/auth_rules",
+            body: parsed,
+            model: Lithic::Models::AuthRules::V2CreateResponse,
+            options: options
+          )
+        end
+
+        # Fetches a V2 authorization rule by its token
+        #
+        # @param auth_rule_token [String] Globally unique identifier for the Auth Rule.
+        #
+        # @param params [Lithic::Models::AuthRules::V2RetrieveParams, Hash{Symbol=>Object}] .
+        #
+        #   @option params [Lithic::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+        #
+        # @return [Lithic::Models::AuthRules::V2RetrieveResponse]
+        def retrieve(auth_rule_token, params = {})
+          @client.request(
+            method: :get,
+            path: ["v2/auth_rules/%0s", auth_rule_token],
+            model: Lithic::Models::AuthRules::V2RetrieveResponse,
+            options: params[:request_options]
+          )
+        end
+
+        # Updates a V2 authorization rule's properties
+        #
+        #   If `account_tokens`, `card_tokens`, `program_level`, or `excluded_card_tokens`
+        #   is provided, this will replace existing associations with the provided list of
+        #   entities.
+        #
+        # @param auth_rule_token [String] Globally unique identifier for the Auth Rule.
+        #
+        # @param params [Lithic::Models::AuthRules::V2UpdateParams, Hash{Symbol=>Object}] .
+        #
+        #   @option params [Array<String>] :account_tokens Account tokens to which the Auth Rule applies.
+        #
+        #   @option params [String, nil] :name Auth Rule Name
+        #
+        #   @option params [Symbol, Lithic::Models::AuthRules::V2UpdateParams::State] :state The desired state of the Auth Rule.
+        #
+        #     Note that only deactivating an Auth Rule through this endpoint is supported at
+        #     this time. If you need to (re-)activate an Auth Rule the /promote endpoint
+        #     should be used to promote a draft to the currently active version.
+        #
+        #   @option params [Array<String>] :card_tokens Card tokens to which the Auth Rule applies.
+        #
+        #   @option params [Array<String>] :excluded_card_tokens Card tokens to which the Auth Rule does not apply.
+        #
+        #   @option params [Boolean] :program_level Whether the Auth Rule applies to all authorizations on the card program.
+        #
+        #   @option params [Lithic::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+        #
+        # @return [Lithic::Models::AuthRules::V2UpdateResponse]
+        def update(auth_rule_token, params = {})
+          parsed, options = Lithic::Models::AuthRules::V2UpdateParams.dump_request(params)
+          @client.request(
+            method: :patch,
+            path: ["v2/auth_rules/%0s", auth_rule_token],
+            body: parsed,
+            model: Lithic::Models::AuthRules::V2UpdateResponse,
+            options: options
+          )
+        end
+
+        # Lists V2 authorization rules
+        #
+        # @param params [Lithic::Models::AuthRules::V2ListParams, Hash{Symbol=>Object}] .
+        #
+        #   @option params [String] :account_token Only return Authorization Rules that are bound to the provided account token.
+        #
+        #   @option params [String] :card_token Only return Authorization Rules that are bound to the provided card token.
+        #
+        #   @option params [String] :ending_before A cursor representing an item's token before which a page of results should end.
+        #     Used to retrieve the previous page of results before this item.
+        #
+        #   @option params [Integer] :page_size Page size (for pagination).
+        #
+        #   @option params [String] :starting_after A cursor representing an item's token after which a page of results should
+        #     begin. Used to retrieve the next page of results after this item.
+        #
+        #   @option params [Lithic::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+        #
+        # @return [Lithic::CursorPage<Lithic::Models::AuthRules::V2ListResponse>]
+        def list(params = {})
+          parsed, options = Lithic::Models::AuthRules::V2ListParams.dump_request(params)
+          @client.request(
+            method: :get,
+            path: "v2/auth_rules",
+            query: parsed,
+            page: Lithic::CursorPage,
+            model: Lithic::Models::AuthRules::V2ListResponse,
+            options: options
+          )
+        end
+
+        # Deletes a V2 authorization rule
+        #
+        # @param auth_rule_token [String] Globally unique identifier for the Auth Rule.
+        #
+        # @param params [Lithic::Models::AuthRules::V2DeleteParams, Hash{Symbol=>Object}] .
+        #
+        #   @option params [Lithic::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+        #
+        # @return [nil]
+        def delete(auth_rule_token, params = {})
+          @client.request(
+            method: :delete,
+            path: ["v2/auth_rules/%0s", auth_rule_token],
+            model: NilClass,
+            options: params[:request_options]
+          )
+        end
+
+        # Associates a V2 authorization rule with a card program, the provided account(s)
+        #   or card(s).
+        #
+        #   Prefer using the `PATCH` method for this operation.
+        #
+        # @param auth_rule_token [String] Globally unique identifier for the Auth Rule.
+        #
+        # @param params [Lithic::Models::AuthRules::V2ApplyParams, Hash{Symbol=>Object}] .
+        #
+        #   @option params [Array<String>] :account_tokens Account tokens to which the Auth Rule applies.
+        #
+        #   @option params [Array<String>] :card_tokens Card tokens to which the Auth Rule applies.
+        #
+        #   @option params [Boolean] :program_level Whether the Auth Rule applies to all authorizations on the card program.
+        #
+        #   @option params [Array<String>] :excluded_card_tokens Card tokens to which the Auth Rule does not apply.
+        #
+        #   @option params [Lithic::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+        #
+        # @return [Lithic::Models::AuthRules::V2ApplyResponse]
+        def apply(auth_rule_token, params)
+          parsed, options = Lithic::Models::AuthRules::V2ApplyParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: ["v2/auth_rules/%0s/apply", auth_rule_token],
+            body: parsed,
+            model: Lithic::Models::AuthRules::V2ApplyResponse,
+            options: options
+          )
+        end
+
+        # Creates a new draft version of a rule that will be ran in shadow mode.
+        #
+        #   This can also be utilized to reset the draft parameters, causing a draft version
+        #   to no longer be ran in shadow mode.
+        #
+        # @param auth_rule_token [String] Globally unique identifier for the Auth Rule.
+        #
+        # @param params [Lithic::Models::AuthRules::V2DraftParams, Hash{Symbol=>Object}] .
+        #
+        #   @option params [Lithic::Models::AuthRules::ConditionalBlockParameters, Lithic::Models::AuthRules::VelocityLimitParams, nil] :parameters Parameters for the Auth Rule
+        #
+        #   @option params [Lithic::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+        #
+        # @return [Lithic::Models::AuthRules::V2DraftResponse]
+        def draft(auth_rule_token, params = {})
+          parsed, options = Lithic::Models::AuthRules::V2DraftParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: ["v2/auth_rules/%0s/draft", auth_rule_token],
+            body: parsed,
+            model: Lithic::Models::AuthRules::V2DraftResponse,
+            options: options
+          )
+        end
+
+        # Promotes the draft version of an authorization rule to the currently active
+        #   version such that it is enforced in the authorization stream.
+        #
+        # @param auth_rule_token [String] Globally unique identifier for the Auth Rule.
+        #
+        # @param params [Lithic::Models::AuthRules::V2PromoteParams, Hash{Symbol=>Object}] .
+        #
+        #   @option params [Lithic::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+        #
+        # @return [Lithic::Models::AuthRules::V2PromoteResponse]
+        def promote(auth_rule_token, params = {})
+          @client.request(
+            method: :post,
+            path: ["v2/auth_rules/%0s/promote", auth_rule_token],
+            model: Lithic::Models::AuthRules::V2PromoteResponse,
+            options: params[:request_options]
+          )
+        end
+
+        # Requests a performance report of an authorization rule to be asynchronously
+        #   generated. Reports can only be run on rules in draft or active mode and will
+        #   included approved and declined statistics as well as examples. The generated
+        #   report will be delivered asynchronously through a webhook with `event_type` =
+        #   `auth_rules.performance_report.created`. See the docs on setting up
+        #   [webhook subscriptions](https://docs.lithic.com/docs/events-api).
+        #
+        #   Reports are generated based on data collected by Lithic's authorization
+        #   processing system in the trailing week. The performance of the auth rule will be
+        #   assessed on the configuration of the auth rule at the time the report is
+        #   requested. This implies that if a performance report is requested, right after
+        #   updating an auth rule, depending on the number of authorizations processed for a
+        #   card program, it may be the case that no data is available for the report.
+        #   Therefore Lithic recommends to decouple making updates to an Auth Rule, and
+        #   requesting performance reports.
+        #
+        #   To make this concrete, consider the following example:
+        #
+        #   1. At time `t`, a new Auth Rule is created, and applies to all authorizations on
+        #      a card program. The Auth Rule has not yet been promoted, causing the draft
+        #      version of the rule to be applied in shadow mode.
+        #   2. At time `t + 1 hour` a performance report is requested for the Auth Rule.
+        #      This performance report will _only_ contain data for the Auth Rule being
+        #      executed in the window between `t` and `t + 1 hour`. This is because Lithic's
+        #      transaction processing system will only start capturing data for the Auth
+        #      Rule at the time it is created.
+        #   3. At time `t + 2 hours` the draft version of the Auth Rule is promoted to the
+        #      active version of the Auth Rule by calling the
+        #      `/v2/auth_rules/{auth_rule_token}/promote` endpoint. If a performance report
+        #      is requested at this moment it will still only contain data for this version
+        #      of the rule, but the window of available data will now span from `t` to
+        #      `t + 2 hours`.
+        #   4. At time `t + 3 hours` a new version of the rule is drafted by calling the
+        #      `/v2/auth_rules/{auth_rule_token}/draft` endpoint. If a performance report is
+        #      requested right at this moment, it will only contain data for authorizations
+        #      to which both the active version and the draft version is applied. Lithic
+        #      does this to ensure that performance reports represent a fair comparison
+        #      between rules. Because there may be no authorizations in this window, and
+        #      because there may be some lag before data is available in a performance
+        #      report, the requested performance report could contain no to little data.
+        #   5. At time `t + 4 hours` another performance report is requested: this time the
+        #      performance report will contain data from the window between `t + 3 hours`
+        #      and `t + 4 hours`, for any authorizations to which both the current version
+        #      of the authorization rule (in enforcing mode) and the draft version of the
+        #      authorization rule (in shadow mode) applied.
+        #
+        #   Note that generating a report may take up to 15 minutes and that delivery is not
+        #   guaranteed. Customers are required to have created an event subscription to
+        #   receive the webhook. Additionally, there is a delay of approximately 15 minutes
+        #   between when Lithic's transaction processing systems have processed the
+        #   transaction, and when a transaction will be included in the report.
+        #
+        # @param auth_rule_token [String] Globally unique identifier for the Auth Rule.
+        #
+        # @param params [Lithic::Models::AuthRules::V2ReportParams, Hash{Symbol=>Object}] .
+        #
+        #   @option params [Lithic::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+        #
+        # @return [Lithic::Models::AuthRules::V2ReportResponse]
+        def report(auth_rule_token, params = {})
+          @client.request(
+            method: :post,
+            path: ["v2/auth_rules/%0s/report", auth_rule_token],
+            model: Lithic::Models::AuthRules::V2ReportResponse,
+            options: params[:request_options]
+          )
+        end
+
+        # @param client [Lithic::Client]
+        def initialize(client:)
+          @client = client
+          @backtests = Lithic::Resources::AuthRules::V2::Backtests.new(client: client)
+        end
+      end
+    end
+  end
+end

data/lib/lithic/resources/auth_rules.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Lithic
+  module Resources
+    class AuthRules
+      # @return [Lithic::Resources::AuthRules::V2]
+      attr_reader :v2
+
+      # @param client [Lithic::Client]
+      def initialize(client:)
+        @client = client
+        @v2 = Lithic::Resources::AuthRules::V2.new(client: client)
+      end
+    end
+  end
+end

data/lib/lithic/resources/auth_stream_enrollment.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Lithic
+  module Resources
+    class AuthStreamEnrollment
+      # Retrieve the ASA HMAC secret key. If one does not exist for your program yet,
+      #   calling this endpoint will create one for you. The headers (which you can use to
+      #   verify webhooks) will begin appearing shortly after calling this endpoint for
+      #   the first time. See
+      #   [this page](https://docs.lithic.com/docs/auth-stream-access-asa#asa-webhook-verification)
+      #   for more detail about verifying ASA webhooks.
+      #
+      # @param params [Lithic::Models::AuthStreamEnrollmentRetrieveSecretParams, Hash{Symbol=>Object}] .
+      #
+      #   @option params [Lithic::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+      #
+      # @return [Lithic::Models::AuthStreamSecret]
+      def retrieve_secret(params = {})
+        @client.request(
+          method: :get,
+          path: "v1/auth_stream/secret",
+          model: Lithic::Models::AuthStreamSecret,
+          options: params[:request_options]
+        )
+      end
+
+      # Generate a new ASA HMAC secret key. The old ASA HMAC secret key will be
+      #   deactivated 24 hours after a successful request to this endpoint. Make a
+      #   [`GET /auth_stream/secret`](https://docs.lithic.com/reference/getauthstreamsecret)
+      #   request to retrieve the new secret key.
+      #
+      # @param params [Lithic::Models::AuthStreamEnrollmentRotateSecretParams, Hash{Symbol=>Object}] .
+      #
+      #   @option params [Lithic::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+      #
+      # @return [nil]
+      def rotate_secret(params = {})
+        @client.request(
+          method: :post,
+          path: "v1/auth_stream/secret/rotate",
+          model: NilClass,
+          options: params[:request_options]
+        )
+      end
+
+      # @param client [Lithic::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/lithic/resources/balances.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Lithic
+  module Resources
+    class Balances
+      # Get the balances for a program, business, or a given end-user account
+      #
+      # @param params [Lithic::Models::BalanceListParams, Hash{Symbol=>Object}] .
+      #
+      #   @option params [String] :account_token List balances for all financial accounts of a given account_token.
+      #
+      #   @option params [Time] :balance_date UTC date and time of the balances to retrieve. Defaults to latest available
+      #     balances
+      #
+      #   @option params [String] :business_account_token List balances for all financial accounts of a given business_account_token.
+      #
+      #   @option params [Symbol, Lithic::Models::BalanceListParams::FinancialAccountType] :financial_account_type List balances for a given Financial Account type.
+      #
+      #   @option params [Lithic::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+      #
+      # @return [Lithic::SinglePage<Lithic::Models::Balance>]
+      def list(params = {})
+        parsed, options = Lithic::Models::BalanceListParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "v1/balances",
+          query: parsed,
+          page: Lithic::SinglePage,
+          model: Lithic::Models::Balance,
+          options: options
+        )
+      end
+
+      # @param client [Lithic::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end