vatsense 0.1.0

data/rbi/vatsense/models/invoice_customer_input.rbi

@@ -0,0 +1,93 @@
+# typed: strong
+
+module Vatsense
+  module Models
+    class InvoiceCustomerInput < Vatsense::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Vatsense::InvoiceCustomerInput, Vatsense::Internal::AnyHash)
+        end
+
+      # The customer's trading name.
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :address
+
+      sig { params(address: String).void }
+      attr_writer :address
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :company_number
+
+      sig { params(company_number: String).void }
+      attr_writer :company_number
+
+      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 :email
+
+      sig { params(email: String).void }
+      attr_writer :email
+
+      # URL to the customer logo (HTTPS only, .jpg/.png).
+      sig { returns(T.nilable(String)) }
+      attr_reader :logo
+
+      sig { params(logo: String).void }
+      attr_writer :logo
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :vat_number
+
+      sig { params(vat_number: String).void }
+      attr_writer :vat_number
+
+      sig do
+        params(
+          name: String,
+          address: String,
+          company_number: String,
+          country_code: String,
+          email: String,
+          logo: String,
+          vat_number: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The customer's trading name.
+        name:,
+        address: nil,
+        company_number: nil,
+        country_code: nil,
+        email: nil,
+        # URL to the customer logo (HTTPS only, .jpg/.png).
+        logo: nil,
+        vat_number: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            name: String,
+            address: String,
+            company_number: String,
+            country_code: String,
+            email: String,
+            logo: String,
+            vat_number: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/vatsense/models/invoice_delete_params.rbi

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

data/rbi/vatsense/models/invoice_delete_response.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module Vatsense
+  module Models
+    class InvoiceDeleteResponse < Vatsense::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Vatsense::Models::InvoiceDeleteResponse,
+            Vatsense::Internal::AnyHash
+          )
+        end
+
+      sig { returns(Integer) }
+      attr_accessor :code
+
+      sig { returns(T::Boolean) }
+      attr_accessor :success
+
+      sig do
+        params(code: Integer, success: T::Boolean).returns(T.attached_class)
+      end
+      def self.new(code:, success:)
+      end
+
+      sig { override.returns({ code: Integer, success: T::Boolean }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/vatsense/models/invoice_list_params.rbi

@@ -0,0 +1,68 @@
+# typed: strong
+
+module Vatsense
+  module Models
+    class InvoiceListParams < Vatsense::Internal::Type::BaseModel
+      extend Vatsense::Internal::Type::RequestParameters::Converter
+      include Vatsense::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Vatsense::InvoiceListParams, Vatsense::Internal::AnyHash)
+        end
+
+      # Number of invoices to return (default 10, max 100).
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :limit
+
+      sig { params(limit: Integer).void }
+      attr_writer :limit
+
+      # Number of invoices to skip (default 0).
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :offset
+
+      sig { params(offset: Integer).void }
+      attr_writer :offset
+
+      # Search query to filter invoices.
+      sig { returns(T.nilable(String)) }
+      attr_reader :search
+
+      sig { params(search: String).void }
+      attr_writer :search
+
+      sig do
+        params(
+          limit: Integer,
+          offset: Integer,
+          search: String,
+          request_options: Vatsense::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Number of invoices to return (default 10, max 100).
+        limit: nil,
+        # Number of invoices to skip (default 0).
+        offset: nil,
+        # Search query to filter invoices.
+        search: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            limit: Integer,
+            offset: Integer,
+            search: String,
+            request_options: Vatsense::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/vatsense/models/invoice_list_response.rbi

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

data/rbi/vatsense/models/invoice_response.rbi

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

data/rbi/vatsense/models/invoice_retrieve_params.rbi

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

data/rbi/vatsense/models/invoice_update_params.rbi

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

data/rbi/vatsense/models/rate.rbi

@@ -0,0 +1,119 @@
+# typed: strong
+
+module Vatsense
+  module Models
+    class Rate < Vatsense::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Vatsense::Rate, Vatsense::Internal::AnyHash) }
+
+      # 2-character ISO 3166-1 alpha-2 country code.
+      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
+
+      # Whether the country is an EU member.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :eu
+
+      sig { params(eu: T::Boolean).void }
+      attr_writer :eu
+
+      sig { returns(T.nilable(Vatsense::Rate::Object::TaggedSymbol)) }
+      attr_reader :object
+
+      sig { params(object: Vatsense::Rate::Object::OrSymbol).void }
+      attr_writer :object
+
+      # A list of other tax rates. Null if no additional rates exist.
+      sig { returns(T.nilable(T::Array[Vatsense::Rate::Other])) }
+      attr_accessor :other
+
+      sig { returns(T.nilable(Vatsense::TaxRate)) }
+      attr_reader :standard
+
+      sig { params(standard: Vatsense::TaxRate::OrHash).void }
+      attr_writer :standard
+
+      sig do
+        params(
+          country_code: String,
+          country_name: String,
+          eu: T::Boolean,
+          object: Vatsense::Rate::Object::OrSymbol,
+          other: T.nilable(T::Array[Vatsense::Rate::Other::OrHash]),
+          standard: Vatsense::TaxRate::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # 2-character ISO 3166-1 alpha-2 country code.
+        country_code: nil,
+        country_name: nil,
+        # Whether the country is an EU member.
+        eu: nil,
+        object: nil,
+        # A list of other tax rates. Null if no additional rates exist.
+        other: nil,
+        standard: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            country_code: String,
+            country_name: String,
+            eu: T::Boolean,
+            object: Vatsense::Rate::Object::TaggedSymbol,
+            other: T.nilable(T::Array[Vatsense::Rate::Other]),
+            standard: Vatsense::TaxRate
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Object
+        extend Vatsense::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Vatsense::Rate::Object) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        RATE = T.let(:rate, Vatsense::Rate::Object::TaggedSymbol)
+
+        sig { override.returns(T::Array[Vatsense::Rate::Object::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      class Other < Vatsense::Models::TaxRate
+        OrHash =
+          T.type_alias do
+            T.any(Vatsense::Rate::Other, Vatsense::Internal::AnyHash)
+          end
+
+        # The province this rate applies to, if applicable.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :province
+
+        sig { params(province: T.nilable(String)).returns(T.attached_class) }
+        def self.new(
+          # The province this rate applies to, if applicable.
+          province: nil
+        )
+        end
+
+        sig { override.returns({ province: T.nilable(String) }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/vatsense/models/rate_calculate_price_params.rbi

@@ -0,0 +1,144 @@
+# typed: strong
+
+module Vatsense
+  module Models
+    class RateCalculatePriceParams < Vatsense::Internal::Type::BaseModel
+      extend Vatsense::Internal::Type::RequestParameters::Converter
+      include Vatsense::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Vatsense::RateCalculatePriceParams, 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 { returns(Vatsense::RateCalculatePriceParams::TaxType::OrSymbol) }
+      attr_accessor :tax_type
+
+      # 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 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(
+          price: String,
+          tax_type: Vatsense::RateCalculatePriceParams::TaxType::OrSymbol,
+          country_code: String,
+          eu: T::Boolean,
+          ip_address: String,
+          province_code: String,
+          type: String,
+          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 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 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(
+          {
+            price: String,
+            tax_type: Vatsense::RateCalculatePriceParams::TaxType::OrSymbol,
+            country_code: String,
+            eu: T::Boolean,
+            ip_address: String,
+            province_code: String,
+            type: String,
+            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::RateCalculatePriceParams::TaxType)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        INCL =
+          T.let(
+            :incl,
+            Vatsense::RateCalculatePriceParams::TaxType::TaggedSymbol
+          )
+        EXCL =
+          T.let(
+            :excl,
+            Vatsense::RateCalculatePriceParams::TaxType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Vatsense::RateCalculatePriceParams::TaxType::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end