io-complyance-unify-sdk 3.0.0

data/lib/complyance_sdk/models/environment.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module ComplyanceSDK
+  module Models
+    # Environment enumeration with direct URL mapping
+    # Matches the Java SDK's Environment enum
+    module Environment
+      # Development environment
+      DEV = :dev
+      
+      # Test environment
+      TEST = :test
+      
+      # Staging environment
+      STAGE = :stage
+      
+      # Local environment
+      LOCAL = :local
+      
+      # Sandbox environment (maps to DEV URL)
+      SANDBOX = :sandbox
+      
+      # Simulation environment (maps to PROD URL)
+      SIMULATION = :simulation
+      
+      # Production environment
+      PRODUCTION = :production
+
+      # Environment to URL mapping (matches Java SDK exactly)
+      URL_MAPPING = {
+        DEV => 'https://dev.gets.complyance.io/unify',
+        TEST => 'https://dev.gets.complyance.io/unify',
+        STAGE => 'https://dev.gets.complyance.io/unify',
+        LOCAL => 'http://127.0.0.1:4001/unify',
+        SANDBOX => 'https://dev.gets.complyance.io/unify',     # Maps to DEV URL
+        SIMULATION => 'https://dev.gets.complyance.io/unify',      # Maps to PROD URL
+        PRODUCTION => 'https://dev.gets.complyance.io/unify'       # Production URL
+      }.freeze
+      
+      # Get the base URL for the given environment
+      #
+      # @param environment [Symbol] The environment
+      # @return [String] The base URL for the environment
+      def self.base_url(environment)
+        url = URL_MAPPING[environment]
+        if url.nil?
+          raise ArgumentError, "Invalid environment: #{environment}. Valid environments: #{all.join(', ')}"
+        end
+        url
+      end
+      
+      # Get all valid environments
+      #
+      # @return [Array<Symbol>] All valid environments
+      def self.all
+        URL_MAPPING.keys
+      end
+
+      # Check if environment is valid
+      #
+      # @param environment [Symbol] The environment to validate
+      # @return [Boolean] True if valid, false otherwise
+      def self.valid?(environment)
+        URL_MAPPING.key?(environment)
+      end
+
+      # Parse string to environment symbol
+      #
+      # @param str [String] The string to parse
+      # @return [Symbol] The environment symbol
+      # @raise [ArgumentError] If the string is invalid
+      def self.from_string(str)
+        return str if str.is_a?(Symbol)
+        
+        env = str.to_s.downcase.to_sym
+        
+        unless valid?(env)
+          raise ArgumentError, "Invalid environment: #{str}. Valid environments: #{all.join(', ')}"
+        end
+        
+        env
+      end
+
+      # Convert environment to string format
+      #
+      # @param environment [Symbol] The environment
+      # @return [String] The string representation
+      def self.to_string(environment)
+        environment.to_s.upcase
+      end
+
+      # Check if environment is a production environment
+      # Production environments have country restrictions
+      #
+      # @param environment [Symbol] The environment
+      # @return [Boolean] True if production environment
+      def self.production_environment?(environment)
+        [SANDBOX, SIMULATION, PRODUCTION].include?(environment)
+      end
+
+      # Check if environment is a development environment
+      # Development environments allow all countries
+      #
+      # @param environment [Symbol] The environment
+      # @return [Boolean] True if development environment
+      def self.development_environment?(environment)
+        [DEV, TEST, STAGE, LOCAL].include?(environment)
+      end
+
+      # Map environment to API value (for backend compatibility)
+      # The API expects "sandbox", "simulation", or "prod"
+      #
+      # @param environment [Symbol] The environment
+      # @return [String] The API environment value
+      def self.to_api_value(environment)
+        case environment
+        when LOCAL, DEV, TEST, STAGE, SANDBOX
+          'sandbox'
+        when SIMULATION
+          'simulation'
+        when PRODUCTION
+          'prod'
+        else
+          'sandbox' # Default to sandbox for safety
+        end
+      end
+
+      # Legacy support - maintain backward compatibility
+      # @deprecated Use the specific environment constants instead
+      def self.legacy_base_url(environment)
+        case environment
+        when :production
+          URL_MAPPING[PRODUCTION]
+        when :sandbox
+          URL_MAPPING[SANDBOX]
+        when :local
+          URL_MAPPING[LOCAL]
+        else
+          base_url(environment)
+        end
+      end
+    end
+  end
+end

data/lib/complyance_sdk/models/logical_doc_type.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module ComplyanceSDK
+  module Models
+    # Logical document type enumeration for business-level document classification
+    # Supports both B2B and B2C tax invoice types with various modifiers
+    class LogicalDocType
+      # Base types
+      INVOICE = :invoice
+      CREDIT_NOTE = :credit_note
+      DEBIT_NOTE = :debit_note
+      RECEIPT = :receipt
+
+      # B2B Tax Invoice types
+      TAX_INVOICE = :tax_invoice
+      TAX_INVOICE_CREDIT_NOTE = :tax_invoice_credit_note
+      TAX_INVOICE_DEBIT_NOTE = :tax_invoice_debit_note
+      TAX_INVOICE_PREPAYMENT = :tax_invoice_prepayment
+      TAX_INVOICE_PREPAYMENT_ADJUSTED = :tax_invoice_prepayment_adjusted
+      TAX_INVOICE_EXPORT_INVOICE = :tax_invoice_export_invoice
+      TAX_INVOICE_EXPORT_CREDIT_NOTE = :tax_invoice_export_credit_note
+      TAX_INVOICE_EXPORT_DEBIT_NOTE = :tax_invoice_export_debit_note
+      TAX_INVOICE_THIRD_PARTY_INVOICE = :tax_invoice_third_party_invoice
+      TAX_INVOICE_SELF_BILLED_INVOICE = :tax_invoice_self_billed_invoice
+      TAX_INVOICE_NOMINAL_SUPPLY_INVOICE = :tax_invoice_nominal_supply_invoice
+      TAX_INVOICE_SUMMARY_INVOICE = :tax_invoice_summary_invoice
+
+      # B2C Simplified Tax Invoice types
+      SIMPLIFIED_TAX_INVOICE = :simplified_tax_invoice
+      SIMPLIFIED_TAX_INVOICE_CREDIT_NOTE = :simplified_tax_invoice_credit_note
+      SIMPLIFIED_TAX_INVOICE_DEBIT_NOTE = :simplified_tax_invoice_debit_note
+      SIMPLIFIED_TAX_INVOICE_PREPAYMENT = :simplified_tax_invoice_prepayment
+      SIMPLIFIED_TAX_INVOICE_PREPAYMENT_ADJUSTED = :simplified_tax_invoice_prepayment_adjusted
+      SIMPLIFIED_TAX_INVOICE_EXPORT_INVOICE = :simplified_tax_invoice_export_invoice
+      SIMPLIFIED_TAX_INVOICE_EXPORT_CREDIT_NOTE = :simplified_tax_invoice_export_credit_note
+      SIMPLIFIED_TAX_INVOICE_EXPORT_DEBIT_NOTE = :simplified_tax_invoice_export_debit_note
+      SIMPLIFIED_TAX_INVOICE_THIRD_PARTY_INVOICE = :simplified_tax_invoice_third_party_invoice
+      SIMPLIFIED_TAX_INVOICE_SELF_BILLED_INVOICE = :simplified_tax_invoice_self_billed_invoice
+      SIMPLIFIED_TAX_INVOICE_NOMINAL_SUPPLY_INVOICE = :simplified_tax_invoice_nominal_supply_invoice
+      SIMPLIFIED_TAX_INVOICE_SUMMARY_INVOICE = :simplified_tax_invoice_summary_invoice
+
+      # Country-specific logical types (legacy support)
+      EXPORT_INVOICE = :export_invoice
+      EXPORT_CREDIT_NOTE = :export_credit_note
+      EXPORT_THIRD_PARTY_INVOICE = :export_third_party_invoice
+      THIRD_PARTY_INVOICE = :third_party_invoice
+      SELF_BILLED_INVOICE = :self_billed_invoice
+      NOMINAL_SUPPLY_INVOICE = :nominal_supply_invoice
+      SUMMARY_INVOICE = :summary_invoice
+
+      # All valid logical document types
+      ALL_TYPES = [
+        INVOICE, CREDIT_NOTE, DEBIT_NOTE, RECEIPT,
+        TAX_INVOICE, TAX_INVOICE_CREDIT_NOTE, TAX_INVOICE_DEBIT_NOTE,
+        TAX_INVOICE_PREPAYMENT, TAX_INVOICE_PREPAYMENT_ADJUSTED,
+        TAX_INVOICE_EXPORT_INVOICE, TAX_INVOICE_EXPORT_CREDIT_NOTE, TAX_INVOICE_EXPORT_DEBIT_NOTE,
+        TAX_INVOICE_THIRD_PARTY_INVOICE, TAX_INVOICE_SELF_BILLED_INVOICE,
+        TAX_INVOICE_NOMINAL_SUPPLY_INVOICE, TAX_INVOICE_SUMMARY_INVOICE,
+        SIMPLIFIED_TAX_INVOICE, SIMPLIFIED_TAX_INVOICE_CREDIT_NOTE, SIMPLIFIED_TAX_INVOICE_DEBIT_NOTE,
+        SIMPLIFIED_TAX_INVOICE_PREPAYMENT, SIMPLIFIED_TAX_INVOICE_PREPAYMENT_ADJUSTED,
+        SIMPLIFIED_TAX_INVOICE_EXPORT_INVOICE, SIMPLIFIED_TAX_INVOICE_EXPORT_CREDIT_NOTE, SIMPLIFIED_TAX_INVOICE_EXPORT_DEBIT_NOTE,
+        SIMPLIFIED_TAX_INVOICE_THIRD_PARTY_INVOICE, SIMPLIFIED_TAX_INVOICE_SELF_BILLED_INVOICE,
+        SIMPLIFIED_TAX_INVOICE_NOMINAL_SUPPLY_INVOICE, SIMPLIFIED_TAX_INVOICE_SUMMARY_INVOICE,
+        EXPORT_INVOICE, EXPORT_CREDIT_NOTE, EXPORT_THIRD_PARTY_INVOICE,
+        THIRD_PARTY_INVOICE, SELF_BILLED_INVOICE, NOMINAL_SUPPLY_INVOICE, SUMMARY_INVOICE
+      ].freeze
+
+      class << self
+        # Check if a logical document type is valid
+        #
+        # @param type [Symbol] The logical document type to validate
+        # @return [Boolean] True if valid, false otherwise
+        def valid?(type)
+          ALL_TYPES.include?(type)
+        end
+
+        # Parse a string to a logical document type symbol
+        #
+        # @param str [String] The string to parse
+        # @return [Symbol] The logical document type symbol
+        # @raise [ArgumentError] If the string is invalid
+        def from_string(str)
+          return str if str.is_a?(Symbol)
+          
+          type = str.to_s.downcase.gsub(/[^a-z_]/, '_').to_sym
+          
+          unless valid?(type)
+            raise ArgumentError, "Invalid logical document type: #{str}. Valid types: #{ALL_TYPES.join(', ')}"
+          end
+          
+          type
+        end
+
+        # Convert a logical document type to string format
+        #
+        # @param type [Symbol] The logical document type
+        # @return [String] The string representation
+        def to_string(type)
+          type.to_s.upcase
+        end
+
+        # Check if logical document type contains credit note
+        #
+        # @param type [Symbol] The logical document type
+        # @return [Boolean] True if it's a credit note type
+        def credit_note?(type)
+          type.to_s.include?('credit_note')
+        end
+
+        # Check if logical document type contains debit note
+        #
+        # @param type [Symbol] The logical document type
+        # @return [Boolean] True if it's a debit note type
+        def debit_note?(type)
+          type.to_s.include?('debit_note')
+        end
+
+        # Check if logical document type is B2B (tax invoice)
+        #
+        # @param type [Symbol] The logical document type
+        # @return [Boolean] True if it's a B2B type
+        def b2b?(type)
+          type.to_s.start_with?('tax_invoice')
+        end
+
+        # Check if logical document type is B2C (simplified tax invoice)
+        #
+        # @param type [Symbol] The logical document type
+        # @return [Boolean] True if it's a B2C type
+        def b2c?(type)
+          type.to_s.start_with?('simplified_tax_invoice')
+        end
+
+        # Check if logical document type is export type
+        #
+        # @param type [Symbol] The logical document type
+        # @return [Boolean] True if it's an export type
+        def export?(type)
+          type.to_s.include?('export')
+        end
+
+        # Check if logical document type is third party type
+        #
+        # @param type [Symbol] The logical document type
+        # @return [Boolean] True if it's a third party type
+        def third_party?(type)
+          type.to_s.include?('third_party')
+        end
+
+        # Check if logical document type is self billed type
+        #
+        # @param type [Symbol] The logical document type
+        # @return [Boolean] True if it's a self billed type
+        def self_billed?(type)
+          type.to_s.include?('self_billed')
+        end
+
+        # Check if logical document type is nominal supply type
+        #
+        # @param type [Symbol] The logical document type
+        # @return [Boolean] True if it's a nominal supply type
+        def nominal_supply?(type)
+          type.to_s.include?('nominal_supply')
+        end
+
+        # Check if logical document type is summary type
+        #
+        # @param type [Symbol] The logical document type
+        # @return [Boolean] True if it's a summary type
+        def summary?(type)
+          type.to_s.include?('summary')
+        end
+
+        # Check if logical document type is prepayment type
+        #
+        # @param type [Symbol] The logical document type
+        # @return [Boolean] True if it's a prepayment type
+        def prepayment?(type)
+          type.to_s.include?('prepayment')
+        end
+
+        # Check if logical document type is adjusted type
+        #
+        # @param type [Symbol] The logical document type
+        # @return [Boolean] True if it's an adjusted type
+        def adjusted?(type)
+          type.to_s.include?('adjusted')
+        end
+
+        # Check if logical document type is receipt type
+        #
+        # @param type [Symbol] The logical document type
+        # @return [Boolean] True if it's a receipt type
+        def receipt?(type)
+          type.to_s.include?('receipt')
+        end
+
+        # Get the meta config document type string for a logical type
+        #
+        # @param type [Symbol] The logical document type
+        # @return [String] The meta config document type
+        def meta_config_document_type(type)
+          if credit_note?(type)
+            'credit_note'
+          elsif debit_note?(type)
+            'debit_note'
+          else
+            'tax_invoice'
+          end
+        end
+
+        # Get the document type string for invoice_data field
+        #
+        # @param type [Symbol] The logical document type
+        # @return [String] The document type string for invoice_data
+        def invoice_data_document_type(type)
+          if credit_note?(type)
+            'credit_note'
+          elsif debit_note?(type)
+            'debit_note'
+          else
+            'tax_invoice'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/complyance_sdk/models/mode.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ComplyanceSDK
+  module Models
+    # Mode enumeration
+    module Mode
+      # Documents mode
+      DOCUMENTS = :documents
+      
+      # Templates mode
+      TEMPLATES = :templates
+      
+      # Get all valid modes
+      #
+      # @return [Array<Symbol>] All valid modes
+      def self.all
+        [DOCUMENTS, TEMPLATES]
+      end
+      
+      # Check if a mode is valid
+      #
+      # @param mode [Symbol, String] The mode to check
+      # @return [Boolean] True if valid, false otherwise
+      def self.valid?(mode)
+        return false if mode.nil?
+        all.include?(mode.to_sym)
+      end
+      
+      # Convert string to mode symbol
+      #
+      # @param mode [String, Symbol] The mode
+      # @return [Symbol, nil] The mode symbol or nil if invalid
+      def self.normalize(mode)
+        return nil if mode.nil?
+        
+        case mode.to_s.downcase
+        when "documents"
+          DOCUMENTS
+        when "templates"
+          TEMPLATES
+        else
+          mode.to_sym if valid?(mode)
+        end
+      end
+    end
+  end
+end

data/lib/complyance_sdk/models/operation.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ComplyanceSDK
+  module Models
+    # Operation enumeration
+    module Operation
+      # Single document operation
+      SINGLE = :single
+      
+      # Batch document operation
+      BATCH = :batch
+      
+      # Get all valid operations
+      #
+      # @return [Array<Symbol>] All valid operations
+      def self.all
+        [SINGLE, BATCH]
+      end
+      
+      # Check if an operation is valid
+      #
+      # @param operation [Symbol, String] The operation to check
+      # @return [Boolean] True if valid, false otherwise
+      def self.valid?(operation)
+        return false if operation.nil?
+        all.include?(operation.to_sym)
+      end
+      
+      # Convert string to operation symbol
+      #
+      # @param operation [String, Symbol] The operation
+      # @return [Symbol, nil] The operation symbol or nil if invalid
+      def self.normalize(operation)
+        return nil if operation.nil?
+        
+        case operation.to_s.downcase
+        when "single"
+          SINGLE
+        when "batch"
+          BATCH
+        else
+          operation.to_sym if valid?(operation)
+        end
+      end
+    end
+  end
+end

data/lib/complyance_sdk/models/policy_result.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require_relative 'document_type'
+
+module ComplyanceSDK
+  module Models
+    # Result of evaluating a logical document type policy
+    # Contains the base document type and meta configuration flags
+    class PolicyResult
+      attr_reader :base_type, :meta_config_flags, :document_type
+
+      # Initialize a new policy result
+      #
+      # @param base_type [Symbol] The base document type (from DocumentType)
+      # @param meta_config_flags [Hash] The meta configuration flags
+      # @param document_type [String] The document type string
+      def initialize(base_type, meta_config_flags, document_type)
+        @base_type = base_type
+        @meta_config_flags = meta_config_flags || {}
+        @document_type = document_type
+      end
+
+      # Get the base document type
+      #
+      # @return [Symbol] The base document type
+      def base_document_type
+        @base_type
+      end
+
+      # Get meta configuration flags
+      #
+      # @return [Hash] The meta configuration flags
+      def get_meta_config_flags
+        @meta_config_flags.dup
+      end
+
+      # Get document type string
+      #
+      # @return [String] The document type string
+      def get_document_type
+        @document_type
+      end
+
+      # Check if this is an export type
+      #
+      # @return [Boolean] True if export type
+      def export?
+        @meta_config_flags[:isExport] == true
+      end
+
+      # Check if this is a self-billed type
+      #
+      # @return [Boolean] True if self-billed type
+      def self_billed?
+        @meta_config_flags[:isSelfBilled] == true
+      end
+
+      # Check if this is a third party type
+      #
+      # @return [Boolean] True if third party type
+      def third_party?
+        @meta_config_flags[:isThirdParty] == true
+      end
+
+      # Check if this is a nominal supply type
+      #
+      # @return [Boolean] True if nominal supply type
+      def nominal_supply?
+        @meta_config_flags[:isNominal] == true
+      end
+
+      # Check if this is a summary type
+      #
+      # @return [Boolean] True if summary type
+      def summary?
+        @meta_config_flags[:isSummary] == true
+      end
+
+      # Check if this is a B2B type
+      #
+      # @return [Boolean] True if B2B type
+      def b2b?
+        @meta_config_flags[:isB2B] == true
+      end
+
+      # Check if this is a prepayment type
+      #
+      # @return [Boolean] True if prepayment type
+      def prepayment?
+        @meta_config_flags[:isPrepayment] == true
+      end
+
+      # Check if this is an adjusted type
+      #
+      # @return [Boolean] True if adjusted type
+      def adjusted?
+        @meta_config_flags[:isAdjusted] == true
+      end
+
+      # Check if this is a receipt type
+      #
+      # @return [Boolean] True if receipt type
+      def receipt?
+        @meta_config_flags[:isReceipt] == true
+      end
+
+      # Convert to hash representation
+      #
+      # @return [Hash] Hash representation of the policy result
+      def to_h
+        {
+          base_type: @base_type,
+          meta_config_flags: @meta_config_flags,
+          document_type: @document_type
+        }
+      end
+
+      # String representation
+      #
+      # @return [String] String representation
+      def to_s
+        "PolicyResult{base_type=#{@base_type}, document_type=#{@document_type}, flags=#{@meta_config_flags}}"
+      end
+
+      # Equality comparison
+      #
+      # @param other [PolicyResult] Other policy result to compare
+      # @return [Boolean] True if equal
+      def ==(other)
+        return false unless other.is_a?(PolicyResult)
+        
+        @base_type == other.base_type &&
+          @meta_config_flags == other.meta_config_flags &&
+          @document_type == other.document_type
+      end
+
+      # Hash code for equality
+      #
+      # @return [Integer] Hash code
+      def hash
+        [@base_type, @meta_config_flags, @document_type].hash
+      end
+    end
+  end
+end

data/lib/complyance_sdk/models/purpose.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ComplyanceSDK
+  module Models
+    # Purpose enumeration
+    module Purpose
+      # Mapping purpose
+      MAPPING = :mapping
+      
+      # Invoicing purpose
+      INVOICING = :invoicing
+      
+      # Validation purpose
+      VALIDATION = :validation
+      
+      # Get all valid purposes
+      #
+      # @return [Array<Symbol>] All valid purposes
+      def self.all
+        [MAPPING, INVOICING, VALIDATION]
+      end
+      
+      # Check if a purpose is valid
+      #
+      # @param purpose [Symbol, String] The purpose to check
+      # @return [Boolean] True if valid, false otherwise
+      def self.valid?(purpose)
+        return false if purpose.nil?
+        all.include?(purpose.to_sym)
+      end
+      
+      # Convert string to purpose symbol
+      #
+      # @param purpose [String, Symbol] The purpose
+      # @return [Symbol, nil] The purpose symbol or nil if invalid
+      def self.normalize(purpose)
+        return nil if purpose.nil?
+        
+        case purpose.to_s.downcase
+        when "mapping"
+          MAPPING
+        when "invoicing"
+          INVOICING
+        when "validation"
+          VALIDATION
+        else
+          purpose.to_sym if valid?(purpose)
+        end
+      end
+    end
+  end
+end