vatsense 0.1.0

data/rbi/vatsense/models/rate_calculate_price_response.rbi

@@ -0,0 +1,184 @@
+# typed: strong
+
+module Vatsense
+  module Models
+    class RateCalculatePriceResponse < Vatsense::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Vatsense::Models::RateCalculatePriceResponse,
+            Vatsense::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :code
+
+      sig { params(code: Integer).void }
+      attr_writer :code
+
+      sig do
+        returns(T.nilable(Vatsense::Models::RateCalculatePriceResponse::Data))
+      end
+      attr_reader :data
+
+      sig do
+        params(
+          data: Vatsense::Models::RateCalculatePriceResponse::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::RateCalculatePriceResponse::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::RateCalculatePriceResponse::Data,
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Data < Vatsense::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Vatsense::Models::RateCalculatePriceResponse::Data,
+              Vatsense::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :country_code
+
+        sig { params(country_code: String).void }
+        attr_writer :country_code
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :country_name
+
+        sig { params(country_name: String).void }
+        attr_writer :country_name
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :eu
+
+        sig { params(eu: T::Boolean).void }
+        attr_writer :eu
+
+        sig do
+          returns(
+            T.nilable(
+              Vatsense::Models::RateCalculatePriceResponse::Data::Object::TaggedSymbol
+            )
+          )
+        end
+        attr_reader :object
+
+        sig do
+          params(
+            object:
+              Vatsense::Models::RateCalculatePriceResponse::Data::Object::OrSymbol
+          ).void
+        end
+        attr_writer :object
+
+        sig { returns(T.nilable(Vatsense::TaxRate)) }
+        attr_reader :tax_rate
+
+        sig { params(tax_rate: Vatsense::TaxRate::OrHash).void }
+        attr_writer :tax_rate
+
+        sig { returns(T.nilable(Vatsense::VatPrice)) }
+        attr_reader :vat_price
+
+        sig { params(vat_price: Vatsense::VatPrice::OrHash).void }
+        attr_writer :vat_price
+
+        sig do
+          params(
+            country_code: String,
+            country_name: String,
+            eu: T::Boolean,
+            object:
+              Vatsense::Models::RateCalculatePriceResponse::Data::Object::OrSymbol,
+            tax_rate: Vatsense::TaxRate::OrHash,
+            vat_price: Vatsense::VatPrice::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          country_code: nil,
+          country_name: nil,
+          eu: nil,
+          object: nil,
+          tax_rate: nil,
+          vat_price: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              country_code: String,
+              country_name: String,
+              eu: T::Boolean,
+              object:
+                Vatsense::Models::RateCalculatePriceResponse::Data::Object::TaggedSymbol,
+              tax_rate: Vatsense::TaxRate,
+              vat_price: Vatsense::VatPrice
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Object
+          extend Vatsense::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Vatsense::Models::RateCalculatePriceResponse::Data::Object
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          RATE =
+            T.let(
+              :rate,
+              Vatsense::Models::RateCalculatePriceResponse::Data::Object::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Vatsense::Models::RateCalculatePriceResponse::Data::Object::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/vatsense/models/rate_details_params.rbi

@@ -0,0 +1,109 @@
+# typed: strong
+
+module Vatsense
+  module Models
+    class RateDetailsParams < Vatsense::Internal::Type::BaseModel
+      extend Vatsense::Internal::Type::RequestParameters::Converter
+      include Vatsense::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Vatsense::RateDetailsParams, Vatsense::Internal::AnyHash)
+        end
+
+      # A 2-character ISO 3166-1 alpha-2 country code (e.g. "GB", "FR").
+      sig { returns(T.nilable(String)) }
+      attr_reader :country_code
+
+      sig { params(country_code: String).void }
+      attr_writer :country_code
+
+      # Filter results by EU membership. Use 1 for EU countries only, 0 for non-EU only.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :eu
+
+      sig { params(eu: T::Boolean).void }
+      attr_writer :eu
+
+      # An IPv4 or IPv6 address. If provided, the country will be determined from the IP
+      # address.
+      sig { returns(T.nilable(String)) }
+      attr_reader :ip_address
+
+      sig { params(ip_address: String).void }
+      attr_writer :ip_address
+
+      # A historical date to retrieve rates for (format "YYYY-MM-DD HH:MM:SS"). Must be
+      # a past date.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :period
+
+      sig { params(period: Time).void }
+      attr_writer :period
+
+      # A 2-character province code (e.g. "NU", "NT"). If providing a province code, you
+      # must also provide the relevant country_code.
+      sig { returns(T.nilable(String)) }
+      attr_reader :province_code
+
+      sig { params(province_code: String).void }
+      attr_writer :province_code
+
+      # The product type to find the applicable rate for. See the /rates/types endpoint
+      # for a full list of valid values.
+      sig { returns(T.nilable(String)) }
+      attr_reader :type
+
+      sig { params(type: String).void }
+      attr_writer :type
+
+      sig do
+        params(
+          country_code: String,
+          eu: T::Boolean,
+          ip_address: String,
+          period: Time,
+          province_code: String,
+          type: String,
+          request_options: Vatsense::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # A 2-character ISO 3166-1 alpha-2 country code (e.g. "GB", "FR").
+        country_code: nil,
+        # Filter results by EU membership. Use 1 for EU countries only, 0 for non-EU only.
+        eu: nil,
+        # An IPv4 or IPv6 address. If provided, the country will be determined from the IP
+        # address.
+        ip_address: nil,
+        # A historical date to retrieve rates for (format "YYYY-MM-DD HH:MM:SS"). Must be
+        # a past date.
+        period: nil,
+        # A 2-character province code (e.g. "NU", "NT"). If providing a province code, you
+        # must also provide the relevant country_code.
+        province_code: nil,
+        # The product type to find the applicable rate for. See the /rates/types endpoint
+        # for a full list of valid values.
+        type: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            country_code: String,
+            eu: T::Boolean,
+            ip_address: String,
+            period: Time,
+            province_code: String,
+            type: String,
+            request_options: Vatsense::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/vatsense/models/rate_find_params.rbi

@@ -0,0 +1,109 @@
+# typed: strong
+
+module Vatsense
+  module Models
+    class RateFindParams < Vatsense::Internal::Type::BaseModel
+      extend Vatsense::Internal::Type::RequestParameters::Converter
+      include Vatsense::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Vatsense::RateFindParams, Vatsense::Internal::AnyHash)
+        end
+
+      # A 2-character ISO 3166-1 alpha-2 country code (e.g. "GB", "FR").
+      sig { returns(T.nilable(String)) }
+      attr_reader :country_code
+
+      sig { params(country_code: String).void }
+      attr_writer :country_code
+
+      # Filter results by EU membership. Use 1 for EU countries only, 0 for non-EU only.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :eu
+
+      sig { params(eu: T::Boolean).void }
+      attr_writer :eu
+
+      # An IPv4 or IPv6 address. If provided, the country will be determined from the IP
+      # address.
+      sig { returns(T.nilable(String)) }
+      attr_reader :ip_address
+
+      sig { params(ip_address: String).void }
+      attr_writer :ip_address
+
+      # A historical date to retrieve rates for (format "YYYY-MM-DD HH:MM:SS"). Must be
+      # a past date.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :period
+
+      sig { params(period: Time).void }
+      attr_writer :period
+
+      # A 2-character province code (e.g. "NU", "NT"). If providing a province code, you
+      # must also provide the relevant country_code.
+      sig { returns(T.nilable(String)) }
+      attr_reader :province_code
+
+      sig { params(province_code: String).void }
+      attr_writer :province_code
+
+      # The product type to find the applicable rate for. See the /rates/types endpoint
+      # for a full list of valid values.
+      sig { returns(T.nilable(String)) }
+      attr_reader :type
+
+      sig { params(type: String).void }
+      attr_writer :type
+
+      sig do
+        params(
+          country_code: String,
+          eu: T::Boolean,
+          ip_address: String,
+          period: Time,
+          province_code: String,
+          type: String,
+          request_options: Vatsense::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # A 2-character ISO 3166-1 alpha-2 country code (e.g. "GB", "FR").
+        country_code: nil,
+        # Filter results by EU membership. Use 1 for EU countries only, 0 for non-EU only.
+        eu: nil,
+        # An IPv4 or IPv6 address. If provided, the country will be determined from the IP
+        # address.
+        ip_address: nil,
+        # A historical date to retrieve rates for (format "YYYY-MM-DD HH:MM:SS"). Must be
+        # a past date.
+        period: nil,
+        # A 2-character province code (e.g. "NU", "NT"). If providing a province code, you
+        # must also provide the relevant country_code.
+        province_code: nil,
+        # The product type to find the applicable rate for. See the /rates/types endpoint
+        # for a full list of valid values.
+        type: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            country_code: String,
+            eu: T::Boolean,
+            ip_address: String,
+            period: Time,
+            province_code: String,
+            type: String,
+            request_options: Vatsense::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/vatsense/models/rate_list_params.rbi

@@ -0,0 +1,83 @@
+# typed: strong
+
+module Vatsense
+  module Models
+    class RateListParams < Vatsense::Internal::Type::BaseModel
+      extend Vatsense::Internal::Type::RequestParameters::Converter
+      include Vatsense::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Vatsense::RateListParams, Vatsense::Internal::AnyHash)
+        end
+
+      # A 2-character ISO 3166-1 alpha-2 country code (e.g. "GB", "FR").
+      sig { returns(T.nilable(String)) }
+      attr_reader :country_code
+
+      sig { params(country_code: String).void }
+      attr_writer :country_code
+
+      # Filter results by EU membership. Use 1 for EU countries only, 0 for non-EU only.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :eu
+
+      sig { params(eu: T::Boolean).void }
+      attr_writer :eu
+
+      # An IPv4 or IPv6 address. If provided, the country will be determined from the IP
+      # address.
+      sig { returns(T.nilable(String)) }
+      attr_reader :ip_address
+
+      sig { params(ip_address: String).void }
+      attr_writer :ip_address
+
+      # A historical date to retrieve rates for (format "YYYY-MM-DD HH:MM:SS"). Must be
+      # a past date.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :period
+
+      sig { params(period: Time).void }
+      attr_writer :period
+
+      sig do
+        params(
+          country_code: String,
+          eu: T::Boolean,
+          ip_address: String,
+          period: Time,
+          request_options: Vatsense::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # A 2-character ISO 3166-1 alpha-2 country code (e.g. "GB", "FR").
+        country_code: nil,
+        # Filter results by EU membership. Use 1 for EU countries only, 0 for non-EU only.
+        eu: nil,
+        # An IPv4 or IPv6 address. If provided, the country will be determined from the IP
+        # address.
+        ip_address: nil,
+        # A historical date to retrieve rates for (format "YYYY-MM-DD HH:MM:SS"). Must be
+        # a past date.
+        period: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            country_code: String,
+            eu: T::Boolean,
+            ip_address: String,
+            period: Time,
+            request_options: Vatsense::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/vatsense/models/rate_list_response.rbi

@@ -0,0 +1,48 @@
+# typed: strong
+
+module Vatsense
+  module Models
+    class RateListResponse < Vatsense::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Vatsense::Models::RateListResponse, Vatsense::Internal::AnyHash)
+        end
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :code
+
+      sig { params(code: Integer).void }
+      attr_writer :code
+
+      sig { returns(T.nilable(T::Array[Vatsense::Rate])) }
+      attr_reader :data
+
+      sig { params(data: T::Array[Vatsense::Rate::OrHash]).void }
+      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: T::Array[Vatsense::Rate::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: T::Array[Vatsense::Rate], success: T::Boolean }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/vatsense/models/rate_list_types_params.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module Vatsense
+  module Models
+    class RateListTypesParams < Vatsense::Internal::Type::BaseModel
+      extend Vatsense::Internal::Type::RequestParameters::Converter
+      include Vatsense::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Vatsense::RateListTypesParams, Vatsense::Internal::AnyHash)
+        end
+
+      sig do
+        params(request_options: Vatsense::RequestOptions::OrHash).returns(
+          T.attached_class
+        )
+      end
+      def self.new(request_options: {})
+      end
+
+      sig { override.returns({ request_options: Vatsense::RequestOptions }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/vatsense/models/rate_list_types_response.rbi

@@ -0,0 +1,51 @@
+# typed: strong
+
+module Vatsense
+  module Models
+    class RateListTypesResponse < Vatsense::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Vatsense::Models::RateListTypesResponse,
+            Vatsense::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :code
+
+      sig { params(code: Integer).void }
+      attr_writer :code
+
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :data
+
+      sig { params(data: T::Array[String]).void }
+      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: T::Array[String],
+          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: T::Array[String], success: T::Boolean }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/vatsense/models/rate_with_tax_rate.rbi

@@ -0,0 +1,94 @@
+# typed: strong
+
+module Vatsense
+  module Models
+    class RateWithTaxRate < Vatsense::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Vatsense::RateWithTaxRate, Vatsense::Internal::AnyHash)
+        end
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :country_code
+
+      sig { params(country_code: String).void }
+      attr_writer :country_code
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :country_name
+
+      sig { params(country_name: String).void }
+      attr_writer :country_name
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :eu
+
+      sig { params(eu: T::Boolean).void }
+      attr_writer :eu
+
+      sig do
+        returns(T.nilable(Vatsense::RateWithTaxRate::Object::TaggedSymbol))
+      end
+      attr_reader :object
+
+      sig { params(object: Vatsense::RateWithTaxRate::Object::OrSymbol).void }
+      attr_writer :object
+
+      sig { returns(T.nilable(Vatsense::TaxRate)) }
+      attr_reader :tax_rate
+
+      sig { params(tax_rate: Vatsense::TaxRate::OrHash).void }
+      attr_writer :tax_rate
+
+      sig do
+        params(
+          country_code: String,
+          country_name: String,
+          eu: T::Boolean,
+          object: Vatsense::RateWithTaxRate::Object::OrSymbol,
+          tax_rate: Vatsense::TaxRate::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        country_code: nil,
+        country_name: nil,
+        eu: nil,
+        object: nil,
+        tax_rate: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            country_code: String,
+            country_name: String,
+            eu: T::Boolean,
+            object: Vatsense::RateWithTaxRate::Object::TaggedSymbol,
+            tax_rate: Vatsense::TaxRate
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Object
+        extend Vatsense::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Vatsense::RateWithTaxRate::Object) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        RATE = T.let(:rate, Vatsense::RateWithTaxRate::Object::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Vatsense::RateWithTaxRate::Object::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end