vatsense 0.1.0

data/rbi/vatsense/models/country_list_provinces_params.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module Vatsense
+  module Models
+    class CountryListProvincesParams < Vatsense::Internal::Type::BaseModel
+      extend Vatsense::Internal::Type::RequestParameters::Converter
+      include Vatsense::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Vatsense::CountryListProvincesParams,
+            Vatsense::Internal::AnyHash
+          )
+        end
+
+      # A 2-character ISO 3166-1 alpha-2 country code (e.g. "CA").
+      sig { returns(String) }
+      attr_accessor :country_code
+
+      sig do
+        params(
+          country_code: 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. "CA").
+        country_code:,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          { country_code: String, request_options: Vatsense::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/vatsense/models/country_list_provinces_response.rbi

@@ -0,0 +1,177 @@
+# typed: strong
+
+module Vatsense
+  module Models
+    class CountryListProvincesResponse < Vatsense::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Vatsense::Models::CountryListProvincesResponse,
+            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(
+            T::Array[Vatsense::Models::CountryListProvincesResponse::Data]
+          )
+        )
+      end
+      attr_reader :data
+
+      sig do
+        params(
+          data:
+            T::Array[
+              Vatsense::Models::CountryListProvincesResponse::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:
+            T::Array[
+              Vatsense::Models::CountryListProvincesResponse::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:
+              T::Array[Vatsense::Models::CountryListProvincesResponse::Data],
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Data < Vatsense::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Vatsense::Models::CountryListProvincesResponse::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 do
+          returns(
+            T.nilable(
+              Vatsense::Models::CountryListProvincesResponse::Data::Object::TaggedSymbol
+            )
+          )
+        end
+        attr_reader :object
+
+        sig do
+          params(
+            object:
+              Vatsense::Models::CountryListProvincesResponse::Data::Object::OrSymbol
+          ).void
+        end
+        attr_writer :object
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :province_code
+
+        sig { params(province_code: String).void }
+        attr_writer :province_code
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :province_name
+
+        sig { params(province_name: String).void }
+        attr_writer :province_name
+
+        sig do
+          params(
+            country_code: String,
+            object:
+              Vatsense::Models::CountryListProvincesResponse::Data::Object::OrSymbol,
+            province_code: String,
+            province_name: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          country_code: nil,
+          object: nil,
+          province_code: nil,
+          province_name: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              country_code: String,
+              object:
+                Vatsense::Models::CountryListProvincesResponse::Data::Object::TaggedSymbol,
+              province_code: String,
+              province_name: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Object
+          extend Vatsense::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Vatsense::Models::CountryListProvincesResponse::Data::Object
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          PROVINCE =
+            T.let(
+              :province,
+              Vatsense::Models::CountryListProvincesResponse::Data::Object::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Vatsense::Models::CountryListProvincesResponse::Data::Object::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/vatsense/models/country_list_response.rbi

@@ -0,0 +1,55 @@
+# typed: strong
+
+module Vatsense
+  module Models
+    class CountryListResponse < Vatsense::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Vatsense::Models::CountryListResponse,
+            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::Country])) }
+      attr_reader :data
+
+      sig { params(data: T::Array[Vatsense::Country::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::Country::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::Country],
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/vatsense/models/create_invoice.rbi

@@ -0,0 +1,240 @@
+# typed: strong
+
+module Vatsense
+  module Models
+    class CreateInvoice < Vatsense::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Vatsense::CreateInvoice, Vatsense::Internal::AnyHash)
+        end
+
+      sig { returns(Vatsense::InvoiceBusinessInput) }
+      attr_reader :business
+
+      sig { params(business: Vatsense::InvoiceBusinessInput::OrHash).void }
+      attr_writer :business
+
+      # The 3-character currency code the invoice is billed in.
+      sig { returns(String) }
+      attr_accessor :currency_code
+
+      # The date the invoice was issued (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS).
+      sig { returns(String) }
+      attr_accessor :date
+
+      sig { returns(T::Array[Vatsense::Invoice::InvoiceItemInput]) }
+      attr_accessor :items
+
+      # The tax point or "time of supply" (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS).
+      sig { returns(String) }
+      attr_accessor :tax_point
+
+      sig { returns(T.nilable(Vatsense::InvoiceConversionInput)) }
+      attr_reader :conversion
+
+      sig { params(conversion: Vatsense::InvoiceConversionInput::OrHash).void }
+      attr_writer :conversion
+
+      sig { returns(T.nilable(Vatsense::InvoiceCustomerInput)) }
+      attr_reader :customer
+
+      sig { params(customer: Vatsense::InvoiceCustomerInput::OrHash).void }
+      attr_writer :customer
+
+      # Whether the invoice is subject to VAT.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :has_vat
+
+      sig { params(has_vat: T::Boolean).void }
+      attr_writer :has_vat
+
+      # A unique invoice number. If not provided, defaults to an auto-incremented
+      # number.
+      sig { returns(T.nilable(String)) }
+      attr_reader :invoice_number
+
+      sig { params(invoice_number: String).void }
+      attr_writer :invoice_number
+
+      # Whether the invoice is a copy of a primary invoice.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :is_copy
+
+      sig { params(is_copy: T::Boolean).void }
+      attr_writer :is_copy
+
+      # Whether the invoice is zero-rated due to reverse charge.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :is_reverse_charge
+
+      sig { params(is_reverse_charge: T::Boolean).void }
+      attr_writer :is_reverse_charge
+
+      # Any additional notes for the invoice.
+      sig { returns(T.nilable(String)) }
+      attr_reader :notes
+
+      sig { params(notes: String).void }
+      attr_writer :notes
+
+      # Pad the auto-generated invoice number with leading zeros to this length.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :pad_invoice_number
+
+      sig { params(pad_invoice_number: Integer).void }
+      attr_writer :pad_invoice_number
+
+      # A serial prepended to the auto-generated invoice number. Each unique serial has
+      # its own auto-increment range.
+      sig { returns(T.nilable(String)) }
+      attr_reader :serial
+
+      sig { params(serial: String).void }
+      attr_writer :serial
+
+      # Whether item prices include or exclude VAT.
+      sig { returns(T.nilable(Vatsense::CreateInvoice::TaxType::OrSymbol)) }
+      attr_reader :tax_type
+
+      sig { params(tax_type: Vatsense::CreateInvoice::TaxType::OrSymbol).void }
+      attr_writer :tax_type
+
+      # The type of invoice.
+      sig { returns(T.nilable(Vatsense::CreateInvoice::Type::OrSymbol)) }
+      attr_reader :type
+
+      sig { params(type: Vatsense::CreateInvoice::Type::OrSymbol).void }
+      attr_writer :type
+
+      # Whether the invoice has been zero-rated.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :zero_rated
+
+      sig { params(zero_rated: T::Boolean).void }
+      attr_writer :zero_rated
+
+      sig do
+        params(
+          business: Vatsense::InvoiceBusinessInput::OrHash,
+          currency_code: String,
+          date: String,
+          items: T::Array[Vatsense::Invoice::InvoiceItemInput::OrHash],
+          tax_point: String,
+          conversion: Vatsense::InvoiceConversionInput::OrHash,
+          customer: Vatsense::InvoiceCustomerInput::OrHash,
+          has_vat: T::Boolean,
+          invoice_number: String,
+          is_copy: T::Boolean,
+          is_reverse_charge: T::Boolean,
+          notes: String,
+          pad_invoice_number: Integer,
+          serial: String,
+          tax_type: Vatsense::CreateInvoice::TaxType::OrSymbol,
+          type: Vatsense::CreateInvoice::Type::OrSymbol,
+          zero_rated: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        business:,
+        # The 3-character currency code the invoice is billed in.
+        currency_code:,
+        # The date the invoice was issued (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS).
+        date:,
+        items:,
+        # The tax point or "time of supply" (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS).
+        tax_point:,
+        conversion: nil,
+        customer: nil,
+        # Whether the invoice is subject to VAT.
+        has_vat: nil,
+        # A unique invoice number. If not provided, defaults to an auto-incremented
+        # number.
+        invoice_number: nil,
+        # Whether the invoice is a copy of a primary invoice.
+        is_copy: nil,
+        # Whether the invoice is zero-rated due to reverse charge.
+        is_reverse_charge: nil,
+        # Any additional notes for the invoice.
+        notes: nil,
+        # Pad the auto-generated invoice number with leading zeros to this length.
+        pad_invoice_number: nil,
+        # A serial prepended to the auto-generated invoice number. Each unique serial has
+        # its own auto-increment range.
+        serial: nil,
+        # Whether item prices include or exclude VAT.
+        tax_type: nil,
+        # The type of invoice.
+        type: nil,
+        # Whether the invoice has been zero-rated.
+        zero_rated: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            business: Vatsense::InvoiceBusinessInput,
+            currency_code: String,
+            date: String,
+            items: T::Array[Vatsense::Invoice::InvoiceItemInput],
+            tax_point: String,
+            conversion: Vatsense::InvoiceConversionInput,
+            customer: Vatsense::InvoiceCustomerInput,
+            has_vat: T::Boolean,
+            invoice_number: String,
+            is_copy: T::Boolean,
+            is_reverse_charge: T::Boolean,
+            notes: String,
+            pad_invoice_number: Integer,
+            serial: String,
+            tax_type: Vatsense::CreateInvoice::TaxType::OrSymbol,
+            type: Vatsense::CreateInvoice::Type::OrSymbol,
+            zero_rated: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Whether item prices include or exclude VAT.
+      module TaxType
+        extend Vatsense::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Vatsense::CreateInvoice::TaxType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        INCL = T.let(:incl, Vatsense::CreateInvoice::TaxType::TaggedSymbol)
+        EXCL = T.let(:excl, Vatsense::CreateInvoice::TaxType::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Vatsense::CreateInvoice::TaxType::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # The type of invoice.
+      module Type
+        extend Vatsense::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Vatsense::CreateInvoice::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        SALE = T.let(:sale, Vatsense::CreateInvoice::Type::TaggedSymbol)
+        REFUND = T.let(:refund, Vatsense::CreateInvoice::Type::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Vatsense::CreateInvoice::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/vatsense/models/currency_calculate_vat_price_params.rbi

@@ -0,0 +1,100 @@
+# typed: strong
+
+module Vatsense
+  module Models
+    class CurrencyCalculateVatPriceParams < Vatsense::Internal::Type::BaseModel
+      extend Vatsense::Internal::Type::RequestParameters::Converter
+      include Vatsense::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Vatsense::CurrencyCalculateVatPriceParams,
+            Vatsense::Internal::AnyHash
+          )
+        end
+
+      # The price to calculate on. Must be a string with exactly 2 decimal places (e.g.
+      # "30.00", "59.95").
+      sig { returns(String) }
+      attr_accessor :price
+
+      # Whether the provided price is inclusive or exclusive of VAT.
+      sig do
+        returns(Vatsense::CurrencyCalculateVatPriceParams::TaxType::OrSymbol)
+      end
+      attr_accessor :tax_type
+
+      # A percentage VAT rate to use for the calculation.
+      sig { returns(Float) }
+      attr_accessor :vat_rate
+
+      sig do
+        params(
+          price: String,
+          tax_type:
+            Vatsense::CurrencyCalculateVatPriceParams::TaxType::OrSymbol,
+          vat_rate: Float,
+          request_options: Vatsense::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # 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
+
+      sig do
+        override.returns(
+          {
+            price: String,
+            tax_type:
+              Vatsense::CurrencyCalculateVatPriceParams::TaxType::OrSymbol,
+            vat_rate: Float,
+            request_options: Vatsense::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Whether the provided price is inclusive or exclusive of VAT.
+      module TaxType
+        extend Vatsense::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Vatsense::CurrencyCalculateVatPriceParams::TaxType)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        INCL =
+          T.let(
+            :incl,
+            Vatsense::CurrencyCalculateVatPriceParams::TaxType::TaggedSymbol
+          )
+        EXCL =
+          T.let(
+            :excl,
+            Vatsense::CurrencyCalculateVatPriceParams::TaxType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Vatsense::CurrencyCalculateVatPriceParams::TaxType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/vatsense/models/currency_calculate_vat_price_response.rbi

@@ -0,0 +1,51 @@
+# typed: strong
+
+module Vatsense
+  module Models
+    class CurrencyCalculateVatPriceResponse < Vatsense::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Vatsense::Models::CurrencyCalculateVatPriceResponse,
+            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::VatPrice)) }
+      attr_reader :data
+
+      sig { params(data: Vatsense::VatPrice::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: Vatsense::VatPrice::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::VatPrice, success: T::Boolean }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end