vatsense 0.1.0

data/rbi/vatsense/models/validate_check_response.rbi

@@ -0,0 +1,285 @@
+# typed: strong
+
+module Vatsense
+  module Models
+    class ValidateCheckResponse < Vatsense::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Vatsense::Models::ValidateCheckResponse,
+            Vatsense::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :code
+
+      sig { params(code: Integer).void }
+      attr_writer :code
+
+      sig { returns(T.nilable(Vatsense::Models::ValidateCheckResponse::Data)) }
+      attr_reader :data
+
+      sig do
+        params(data: Vatsense::Models::ValidateCheckResponse::Data::OrHash).void
+      end
+      attr_writer :data
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :success
+
+      sig { params(success: T::Boolean).void }
+      attr_writer :success
+
+      sig do
+        params(
+          code: Integer,
+          data: Vatsense::Models::ValidateCheckResponse::Data::OrHash,
+          success: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(code: nil, data: nil, success: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            code: Integer,
+            data: Vatsense::Models::ValidateCheckResponse::Data,
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Data < Vatsense::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Vatsense::Models::ValidateCheckResponse::Data,
+              Vatsense::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(
+            T.nilable(
+              Vatsense::Models::ValidateCheckResponse::Data::Company::Variants
+            )
+          )
+        end
+        attr_reader :company
+
+        sig do
+          params(
+            company:
+              T.any(
+                Vatsense::Models::ValidateCheckResponse::Data::Company::ValidationCompany::OrHash,
+                Vatsense::Models::ValidateCheckResponse::Data::Company::EoriValidationCompany::OrHash
+              )
+          ).void
+        end
+        attr_writer :company
+
+        # Official consultation number (only returned when requester_vat_number is
+        # provided).
+        sig { returns(T.nilable(String)) }
+        attr_accessor :consultation_number
+
+        # Whether the VAT/EORI number is valid.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :valid
+
+        sig { params(valid: T::Boolean).void }
+        attr_writer :valid
+
+        sig do
+          params(
+            company:
+              T.any(
+                Vatsense::Models::ValidateCheckResponse::Data::Company::ValidationCompany::OrHash,
+                Vatsense::Models::ValidateCheckResponse::Data::Company::EoriValidationCompany::OrHash
+              ),
+            consultation_number: T.nilable(String),
+            valid: T::Boolean
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          company: nil,
+          # Official consultation number (only returned when requester_vat_number is
+          # provided).
+          consultation_number: nil,
+          # Whether the VAT/EORI number is valid.
+          valid: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              company:
+                Vatsense::Models::ValidateCheckResponse::Data::Company::Variants,
+              consultation_number: T.nilable(String),
+              valid: T::Boolean
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Company
+          extend Vatsense::Internal::Type::Union
+
+          Variants =
+            T.type_alias do
+              T.any(
+                Vatsense::Models::ValidateCheckResponse::Data::Company::ValidationCompany,
+                Vatsense::Models::ValidateCheckResponse::Data::Company::EoriValidationCompany
+              )
+            end
+
+          class ValidationCompany < Vatsense::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Vatsense::Models::ValidateCheckResponse::Data::Company::ValidationCompany,
+                  Vatsense::Internal::AnyHash
+                )
+              end
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :company_address
+
+            sig { params(company_address: String).void }
+            attr_writer :company_address
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :company_name
+
+            sig { params(company_name: String).void }
+            attr_writer :company_name
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :country_code
+
+            sig { params(country_code: String).void }
+            attr_writer :country_code
+
+            # The VAT number (without country code prefix).
+            sig { returns(T.nilable(String)) }
+            attr_reader :vat_number
+
+            sig { params(vat_number: String).void }
+            attr_writer :vat_number
+
+            sig do
+              params(
+                company_address: String,
+                company_name: String,
+                country_code: String,
+                vat_number: String
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              company_address: nil,
+              company_name: nil,
+              country_code: nil,
+              # The VAT number (without country code prefix).
+              vat_number: nil
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  company_address: String,
+                  company_name: String,
+                  country_code: String,
+                  vat_number: String
+                }
+              )
+            end
+            def to_hash
+            end
+          end
+
+          class EoriValidationCompany < Vatsense::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Vatsense::Models::ValidateCheckResponse::Data::Company::EoriValidationCompany,
+                  Vatsense::Internal::AnyHash
+                )
+              end
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :company_address
+
+            sig { params(company_address: String).void }
+            attr_writer :company_address
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :company_name
+
+            sig { params(company_name: String).void }
+            attr_writer :company_name
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :country_code
+
+            sig { params(country_code: String).void }
+            attr_writer :country_code
+
+            # The EORI number (without country code prefix).
+            sig { returns(T.nilable(String)) }
+            attr_reader :eori_number
+
+            sig { params(eori_number: String).void }
+            attr_writer :eori_number
+
+            sig do
+              params(
+                company_address: String,
+                company_name: String,
+                country_code: String,
+                eori_number: String
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              company_address: nil,
+              company_name: nil,
+              country_code: nil,
+              # The EORI number (without country code prefix).
+              eori_number: nil
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  company_address: String,
+                  company_name: String,
+                  country_code: String,
+                  eori_number: String
+                }
+              )
+            end
+            def to_hash
+            end
+          end
+
+          sig do
+            override.returns(
+              T::Array[
+                Vatsense::Models::ValidateCheckResponse::Data::Company::Variants
+              ]
+            )
+          end
+          def self.variants
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/vatsense/models/vat_price.rbi

@@ -0,0 +1,136 @@
+# typed: strong
+
+module Vatsense
+  module Models
+    class VatPrice < Vatsense::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Vatsense::VatPrice, Vatsense::Internal::AnyHash) }
+
+      sig { returns(T.nilable(Vatsense::VatPrice::Object::TaggedSymbol)) }
+      attr_reader :object
+
+      sig { params(object: Vatsense::VatPrice::Object::OrSymbol).void }
+      attr_writer :object
+
+      # The price provided.
+      sig { returns(T.nilable(Float)) }
+      attr_reader :price
+
+      sig { params(price: Float).void }
+      attr_writer :price
+
+      # The calculated price exclusive of VAT.
+      sig { returns(T.nilable(Float)) }
+      attr_reader :price_excl_vat
+
+      sig { params(price_excl_vat: Float).void }
+      attr_writer :price_excl_vat
+
+      # The calculated price inclusive of VAT.
+      sig { returns(T.nilable(Float)) }
+      attr_reader :price_incl_vat
+
+      sig { params(price_incl_vat: Float).void }
+      attr_writer :price_incl_vat
+
+      # Whether the price is inclusive or exclusive of VAT.
+      sig { returns(T.nilable(Vatsense::VatPrice::TaxType::TaggedSymbol)) }
+      attr_reader :tax_type
+
+      sig { params(tax_type: Vatsense::VatPrice::TaxType::OrSymbol).void }
+      attr_writer :tax_type
+
+      # The total VAT amount.
+      sig { returns(T.nilable(Float)) }
+      attr_reader :vat
+
+      sig { params(vat: Float).void }
+      attr_writer :vat
+
+      # The VAT rate percentage.
+      sig { returns(T.nilable(Float)) }
+      attr_reader :vat_rate
+
+      sig { params(vat_rate: Float).void }
+      attr_writer :vat_rate
+
+      sig do
+        params(
+          object: Vatsense::VatPrice::Object::OrSymbol,
+          price: Float,
+          price_excl_vat: Float,
+          price_incl_vat: Float,
+          tax_type: Vatsense::VatPrice::TaxType::OrSymbol,
+          vat: Float,
+          vat_rate: Float
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        object: nil,
+        # The price provided.
+        price: nil,
+        # The calculated price exclusive of VAT.
+        price_excl_vat: nil,
+        # The calculated price inclusive of VAT.
+        price_incl_vat: nil,
+        # Whether the price is inclusive or exclusive of VAT.
+        tax_type: nil,
+        # The total VAT amount.
+        vat: nil,
+        # The VAT rate percentage.
+        vat_rate: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            object: Vatsense::VatPrice::Object::TaggedSymbol,
+            price: Float,
+            price_excl_vat: Float,
+            price_incl_vat: Float,
+            tax_type: Vatsense::VatPrice::TaxType::TaggedSymbol,
+            vat: Float,
+            vat_rate: Float
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Object
+        extend Vatsense::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Vatsense::VatPrice::Object) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        VAT_PRICE = T.let(:vat_price, Vatsense::VatPrice::Object::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Vatsense::VatPrice::Object::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+
+      # Whether the price is inclusive or exclusive of VAT.
+      module TaxType
+        extend Vatsense::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Vatsense::VatPrice::TaxType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        INCL = T.let(:incl, Vatsense::VatPrice::TaxType::TaggedSymbol)
+        EXCL = T.let(:excl, Vatsense::VatPrice::TaxType::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Vatsense::VatPrice::TaxType::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/vatsense/models.rbi

@@ -0,0 +1,66 @@
+# typed: strong
+
+module Vatsense
+  Country = Vatsense::Models::Country
+
+  CountryListParams = Vatsense::Models::CountryListParams
+
+  CountryListProvincesParams = Vatsense::Models::CountryListProvincesParams
+
+  CreateInvoice = Vatsense::Models::CreateInvoice
+
+  CurrencyCalculateVatPriceParams =
+    Vatsense::Models::CurrencyCalculateVatPriceParams
+
+  CurrencyConvertParams = Vatsense::Models::CurrencyConvertParams
+
+  CurrencyListParams = Vatsense::Models::CurrencyListParams
+
+  FindRate = Vatsense::Models::FindRate
+
+  Invoice = Vatsense::Models::Invoice
+
+  InvoiceAPI = Vatsense::Models::InvoiceAPI
+
+  InvoiceBusinessInput = Vatsense::Models::InvoiceBusinessInput
+
+  InvoiceConversionInput = Vatsense::Models::InvoiceConversionInput
+
+  InvoiceCreateParams = Vatsense::Models::InvoiceCreateParams
+
+  InvoiceCustomerInput = Vatsense::Models::InvoiceCustomerInput
+
+  InvoiceDeleteParams = Vatsense::Models::InvoiceDeleteParams
+
+  InvoiceListParams = Vatsense::Models::InvoiceListParams
+
+  InvoiceResponse = Vatsense::Models::InvoiceResponse
+
+  InvoiceRetrieveParams = Vatsense::Models::InvoiceRetrieveParams
+
+  InvoiceUpdateParams = Vatsense::Models::InvoiceUpdateParams
+
+  Rate = Vatsense::Models::Rate
+
+  RateCalculatePriceParams = Vatsense::Models::RateCalculatePriceParams
+
+  RateDetailsParams = Vatsense::Models::RateDetailsParams
+
+  RateFindParams = Vatsense::Models::RateFindParams
+
+  RateListParams = Vatsense::Models::RateListParams
+
+  RateListTypesParams = Vatsense::Models::RateListTypesParams
+
+  RateWithTaxRate = Vatsense::Models::RateWithTaxRate
+
+  SandboxGenerateKeyParams = Vatsense::Models::SandboxGenerateKeyParams
+
+  TaxRate = Vatsense::Models::TaxRate
+
+  UsageRetrieveParams = Vatsense::Models::UsageRetrieveParams
+
+  ValidateCheckParams = Vatsense::Models::ValidateCheckParams
+
+  VatPrice = Vatsense::Models::VatPrice
+end

data/rbi/vatsense/request_options.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module Vatsense
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  # or override those provided at the client level.
+  #
+  # When making a request, you can pass an actual {RequestOptions} instance, or
+  # simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < Vatsense::Internal::Type::BaseModel
+    OrHash =
+      T.type_alias do
+        T.any(Vatsense::RequestOptions, Vatsense::Internal::AnyHash)
+      end
+
+    # @api private
+    sig { params(opts: Vatsense::RequestOptions::OrHash).void }
+    def self.validate!(opts)
+    end
+
+    # Idempotency key to send with request and all associated retries. Will only be
+    # sent for write requests.
+    sig { returns(T.nilable(String)) }
+    attr_accessor :idempotency_key
+
+    # Extra query params to send with the request. These are `.merge`’d into any
+    # `query` given at the client level.
+    sig do
+      returns(
+        T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])
+      )
+    end
+    attr_accessor :extra_query
+
+    # Extra headers to send with the request. These are `.merged`’d into any
+    # `extra_headers` given at the client level.
+    sig { returns(T.nilable(T::Hash[String, T.nilable(String)])) }
+    attr_accessor :extra_headers
+
+    # Extra data to send with the request. These are deep merged into any data
+    # generated as part of the normal request.
+    sig { returns(T.nilable(T.anything)) }
+    attr_accessor :extra_body
+
+    # Maximum number of retries to attempt after a failed initial request.
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :max_retries
+
+    # Request timeout in seconds.
+    sig { returns(T.nilable(Float)) }
+    attr_accessor :timeout
+
+    # Returns a new instance of RequestOptions.
+    sig do
+      params(values: Vatsense::Internal::AnyHash).returns(T.attached_class)
+    end
+    def self.new(values = {})
+    end
+  end
+end

data/rbi/vatsense/resources/countries.rbi

@@ -0,0 +1,49 @@
+# typed: strong
+
+module Vatsense
+  module Resources
+    # Country and province information
+    class Countries
+      # Returns a list of all countries, including whether they are subject to VAT/GST
+      # and whether they are subject to EU VAT. Each country is returned as a country
+      # object.
+      #
+      # You can optionally filter by country code or IP address.
+      sig do
+        params(
+          country_code: String,
+          ip_address: String,
+          request_options: Vatsense::RequestOptions::OrHash
+        ).returns(Vatsense::Models::CountryListResponse)
+      end
+      def list(
+        # A 2-character ISO 3166-1 alpha-2 country code (e.g. "GB", "FR").
+        country_code: nil,
+        # An IPv4 or IPv6 address. If provided, the country will be determined from the IP
+        # address.
+        ip_address: nil,
+        request_options: {}
+      )
+      end
+
+      # Retrieve a list of all provinces within a given country.
+      sig do
+        params(
+          country_code: String,
+          request_options: Vatsense::RequestOptions::OrHash
+        ).returns(Vatsense::Models::CountryListProvincesResponse)
+      end
+      def list_provinces(
+        # A 2-character ISO 3166-1 alpha-2 country code (e.g. "CA").
+        country_code:,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Vatsense::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/vatsense/resources/currency.rbi

@@ -0,0 +1,82 @@
+# typed: strong
+
+module Vatsense
+  module Resources
+    # Currency exchange rates and conversion
+    class Currency
+      # Returns a list of all currency conversion rates sourced from HMRC (GBP) and the
+      # European Central Bank (EUR).
+      #
+      # You can optionally filter by source and target currency.
+      sig do
+        params(
+          from: String,
+          to: Vatsense::CurrencyListParams::To::OrSymbol,
+          request_options: Vatsense::RequestOptions::OrHash
+        ).returns(Vatsense::Models::CurrencyListResponse)
+      end
+      def list(
+        # The 3-character currency code(s) to convert from (e.g. "USD", "CAD"). Can be a
+        # comma-separated list without spaces (e.g. "USD,CAD,AUD").
+        from: nil,
+        # The 3-character target currency code. Must be either "GBP" or "EUR".
+        to: nil,
+        request_options: {}
+      )
+      end
+
+      # Calculate the inclusive and exclusive VAT price on a given amount and VAT rate.
+      # This is a standalone calculation that does not look up rates by country.
+      sig do
+        params(
+          price: String,
+          tax_type:
+            Vatsense::CurrencyCalculateVatPriceParams::TaxType::OrSymbol,
+          vat_rate: Float,
+          request_options: Vatsense::RequestOptions::OrHash
+        ).returns(Vatsense::Models::CurrencyCalculateVatPriceResponse)
+      end
+      def calculate_vat_price(
+        # The price to calculate on. Must be a string with exactly 2 decimal places (e.g.
+        # "30.00", "59.95").
+        price:,
+        # Whether the provided price is inclusive or exclusive of VAT.
+        tax_type:,
+        # A percentage VAT rate to use for the calculation.
+        vat_rate:,
+        request_options: {}
+      )
+      end
+
+      # Convert a foreign currency amount to either GBP or EUR using official exchange
+      # rates.
+      #
+      # GBP rates are from HMRC (updated on the 1st of every month). EUR rates are from
+      # the European Central Bank (updated around 16:00 CET on working days).
+      sig do
+        params(
+          amount: String,
+          from: String,
+          to: Vatsense::CurrencyConvertParams::To::OrSymbol,
+          request_options: Vatsense::RequestOptions::OrHash
+        ).returns(Vatsense::Models::CurrencyConvertResponse)
+      end
+      def convert(
+        # The amount to convert. Must be a string with exactly 2 decimal places (e.g.
+        # "39.99").
+        amount:,
+        # The 3-character source currency code (e.g. "USD", "CAD").
+        from:,
+        # The 3-character target currency code. Must be either "GBP" or "EUR".
+        to:,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Vatsense::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end