expressir 0.2.0 → 0.2.1

data/spec/expressir/express_exp/remark_spec.rb

@@ -0,0 +1,301 @@
+require "spec_helper"
+require "expressir/express_exp/parser"
+
+RSpec.describe Expressir::ExpressExp::Parser do
+  describe ".from_file" do
+    it "build an instance from a file" do
+      repo = Expressir::ExpressExp::Parser.from_exp(sample_file)
+
+      schema = repo.schemas.first
+
+      schema.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Schema)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(2)
+        expect(x.remarks[0]).to eq("universal scope - schema before")
+        expect(x.remarks[1]).to eq("universal scope - schema")
+      end
+      
+      schema.constants.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Constant)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(2)
+        expect(x.remarks[0]).to eq("schema scope - constant")
+        expect(x.remarks[1]).to eq("universal scope - constant")
+      end
+      
+      schema.types.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Type)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(2)
+        expect(x.remarks[0]).to eq("schema scope - type")
+        expect(x.remarks[1]).to eq("universal scope - type")
+      end
+      
+      schema.entities.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Entity)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(2)
+        expect(x.remarks[0]).to eq("schema scope - entity")
+        expect(x.remarks[1]).to eq("universal scope - entity")
+      end
+      
+      schema.entities.first.explicit.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Explicit)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(3)
+        expect(x.remarks[0]).to eq("entity scope - entity explicit")
+        expect(x.remarks[1]).to eq("schema scope - entity explicit")
+        expect(x.remarks[2]).to eq("universal scope - entity explicit")
+      end
+      
+      schema.entities.first.derived.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Derived)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(3)
+        expect(x.remarks[0]).to eq("entity scope - entity derived")
+        expect(x.remarks[1]).to eq("schema scope - entity derived")
+        expect(x.remarks[2]).to eq("universal scope - entity derived")
+      end
+      
+      schema.entities.first.inverse.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Inverse)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(3)
+        expect(x.remarks[0]).to eq("entity scope - entity inverse")
+        expect(x.remarks[1]).to eq("schema scope - entity inverse")
+        expect(x.remarks[2]).to eq("universal scope - entity inverse")
+      end
+      
+      schema.entities.first.unique.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Unique)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(3)
+        expect(x.remarks[0]).to eq("entity scope - entity unique")
+        expect(x.remarks[1]).to eq("schema scope - entity unique")
+        expect(x.remarks[2]).to eq("universal scope - entity unique")
+      end
+      
+      schema.entities.first.where.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Where)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(3)
+        expect(x.remarks[0]).to eq("entity scope - entity where")
+        expect(x.remarks[1]).to eq("schema scope - entity where")
+        expect(x.remarks[2]).to eq("universal scope - entity where")
+      end
+      
+      schema.subtype_constraints.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::SubtypeConstraint)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(2)
+        expect(x.remarks[0]).to eq("schema scope - subtype constraint")
+        expect(x.remarks[1]).to eq("universal scope - subtype constraint")
+      end
+      
+      schema.functions.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Function)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(2)
+        expect(x.remarks[0]).to eq("schema scope - function")
+        expect(x.remarks[1]).to eq("universal scope - function")
+      end
+      
+      schema.functions.first.parameters.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Parameter)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(3)
+        expect(x.remarks[0]).to eq("function scope - function parameter")
+        expect(x.remarks[1]).to eq("schema scope - function parameter")
+        expect(x.remarks[2]).to eq("universal scope - function parameter")
+      end
+      
+      schema.functions.first.types.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Type)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(3)
+        expect(x.remarks[0]).to eq("function scope - function type")
+        expect(x.remarks[1]).to eq("schema scope - function type")
+        expect(x.remarks[2]).to eq("universal scope - function type")
+      end
+      
+      schema.functions.first.constants.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Constant)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(3)
+        expect(x.remarks[0]).to eq("function scope - function constant")
+        expect(x.remarks[1]).to eq("schema scope - function constant")
+        expect(x.remarks[2]).to eq("universal scope - function constant")
+      end
+      
+      schema.functions.first.locals.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Local)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(3)
+        expect(x.remarks[0]).to eq("function scope - function local")
+        expect(x.remarks[1]).to eq("schema scope - function local")
+        expect(x.remarks[2]).to eq("universal scope - function local")
+      end
+      
+      schema.functions.first.statements[0].tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Statements::Alias)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(1)
+        expect(x.remarks[0]).to eq("function alias scope - function alias")
+      end
+      
+      schema.functions.first.statements[1].tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Statements::Repeat)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(1)
+        expect(x.remarks[0]).to eq("function repeat scope - function repeat")
+      end
+      
+      schema.functions.first.statements[2].tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Statements::Assignment)
+        expect(x.expression).to be_instance_of(Expressir::Model::Expressions::Query)
+        expect(x.expression.remarks).to be_instance_of(Array)
+        expect(x.expression.remarks.count).to eq(1)
+        expect(x.expression.remarks[0]).to eq("function query scope - function query")
+      end
+      
+      schema.procedures.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Procedure)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(2)
+        expect(x.remarks[0]).to eq("schema scope - procedure")
+        expect(x.remarks[1]).to eq("universal scope - procedure")
+      end
+      
+      schema.procedures.first.parameters.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Parameter)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(3)
+        expect(x.remarks[0]).to eq("procedure scope - procedure parameter")
+        expect(x.remarks[1]).to eq("schema scope - procedure parameter")
+        expect(x.remarks[2]).to eq("universal scope - procedure parameter")
+      end
+      
+      schema.procedures.first.types.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Type)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(3)
+        expect(x.remarks[0]).to eq("procedure scope - procedure type")
+        expect(x.remarks[1]).to eq("schema scope - procedure type")
+        expect(x.remarks[2]).to eq("universal scope - procedure type")
+      end
+      
+      schema.procedures.first.constants.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Constant)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(3)
+        expect(x.remarks[0]).to eq("procedure scope - procedure constant")
+        expect(x.remarks[1]).to eq("schema scope - procedure constant")
+        expect(x.remarks[2]).to eq("universal scope - procedure constant")
+      end
+      
+      schema.procedures.first.locals.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Local)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(3)
+        expect(x.remarks[0]).to eq("procedure scope - procedure local")
+        expect(x.remarks[1]).to eq("schema scope - procedure local")
+        expect(x.remarks[2]).to eq("universal scope - procedure local")
+      end
+      
+      schema.procedures.first.statements[0].tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Statements::Alias)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(1)
+        expect(x.remarks[0]).to eq("procedure alias scope - procedure alias")
+      end
+      
+      schema.procedures.first.statements[1].tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Statements::Repeat)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(1)
+        expect(x.remarks[0]).to eq("procedure repeat scope - procedure repeat")
+      end
+      
+      schema.procedures.first.statements[2].tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Statements::Assignment)
+        expect(x.expression).to be_instance_of(Expressir::Model::Expressions::Query)
+        expect(x.expression.remarks).to be_instance_of(Array)
+        expect(x.expression.remarks.count).to eq(1)
+        expect(x.expression.remarks[0]).to eq("procedure query scope - procedure query")
+      end
+      
+      schema.rules.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Rule)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(2)
+        expect(x.remarks[0]).to eq("schema scope - rule")
+        expect(x.remarks[1]).to eq("universal scope - rule")
+      end
+      
+      schema.rules.first.types.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Type)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(3)
+        expect(x.remarks[0]).to eq("rule scope - rule type")
+        expect(x.remarks[1]).to eq("schema scope - rule type")
+        expect(x.remarks[2]).to eq("universal scope - rule type")
+      end
+      
+      schema.rules.first.constants.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Constant)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(3)
+        expect(x.remarks[0]).to eq("rule scope - rule constant")
+        expect(x.remarks[1]).to eq("schema scope - rule constant")
+        expect(x.remarks[2]).to eq("universal scope - rule constant")
+      end
+      
+      schema.rules.first.locals.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Local)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(3)
+        expect(x.remarks[0]).to eq("rule scope - rule local")
+        expect(x.remarks[1]).to eq("schema scope - rule local")
+        expect(x.remarks[2]).to eq("universal scope - rule local")
+      end
+      
+      schema.rules.first.statements[0].tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Statements::Alias)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(1)
+        expect(x.remarks[0]).to eq("rule alias scope - rule alias")
+      end
+      
+      schema.rules.first.statements[1].tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Statements::Repeat)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(1)
+        expect(x.remarks[0]).to eq("rule repeat scope - rule repeat")
+      end
+      
+      schema.rules.first.statements[2].tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Statements::Assignment)
+        expect(x.expression).to be_instance_of(Expressir::Model::Expressions::Query)
+        expect(x.expression.remarks).to be_instance_of(Array)
+        expect(x.expression.remarks.count).to eq(1)
+        expect(x.expression.remarks[0]).to eq("rule query scope - rule query")
+      end
+      
+      schema.rules.first.where.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Where)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(3)
+        expect(x.remarks[0]).to eq("rule scope - rule where")
+        expect(x.remarks[1]).to eq("schema scope - rule where")
+        expect(x.remarks[2]).to eq("universal scope - rule where")
+      end
+    end
+  end
+
+  def sample_file
+    @sample_file ||= Expressir.root_path.join(
+      "original", "examples", "syntax", "remark.exp"
+    )
+  end
+end

data/spec/expressir/express_exp/syntax_spec.rb

@@ -1,5 +1,5 @@
 require "spec_helper"
-require_relative "../../../lib/expressir/express_exp/parser"
+require "expressir/express_exp/parser"
 
 RSpec.describe Expressir::ExpressExp::Parser do
   describe ".from_file" do
@@ -9,7 +9,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
       schemas = repo.schemas
 
       schema = schemas.find{|x| x.id == "syntaxSchema"}
-      expect(schema.version).to eq("version")
+      expect(schema.version).to be_instance_of(Expressir::Model::Literals::String)
+      expect(schema.version.value).to eq("version")
 
       interfaces = schema.interfaces
       constants = schema.constants
@@ -67,35 +68,44 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       # literals
       constants.find{|x| x.id == "binaryExpression"}.expression.tap do |x|
-        expect(x).to eq("xxx")
+        expect(x).to be_instance_of(Expressir::Model::Literals::Binary)
+        expect(x.value).to eq("011110000111100001111000")
       end
 
       constants.find{|x| x.id == "integerExpression"}.expression.tap do |x|
-        expect(x).to eq(999)
+        expect(x).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.value).to eq("999")
       end
 
-      constants.find{|x| x.id == "logicalTrueExpression"}.expression.tap do |x|
-        expect(x).to eq(true)
+      constants.find{|x| x.id == "trueLogicalExpression"}.expression.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.value).to eq(true)
       end
       
-      constants.find{|x| x.id == "logicalFalseExpression"}.expression.tap do |x|
-        expect(x).to eq(false)
+      constants.find{|x| x.id == "falseLogicalExpression"}.expression.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.value).to eq(false)
       end
 
-      constants.find{|x| x.id == "logicalUnknownExpression"}.expression.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Expressions::Unknown)
+      constants.find{|x| x.id == "unknownLogicalExpression"}.expression.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.value).to eq(nil)
       end
 
       constants.find{|x| x.id == "realExpression"}.expression.tap do |x|
-        expect(x).to eq(999.999)
+        expect(x).to be_instance_of(Expressir::Model::Literals::Real)
+        expect(x.value).to eq("999.999")
       end
 
-      constants.find{|x| x.id == "stringSimpleExpression"}.expression.tap do |x|
-        expect(x).to eq("xxx")
+      constants.find{|x| x.id == "simpleStringExpression"}.expression.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.value).to eq("xxx")
       end
 
-      constants.find{|x| x.id == "stringEncodedExpression"}.expression.tap do |x|
-        expect(x).to eq("xxx")
+      constants.find{|x| x.id == "encodedStringExpression"}.expression.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.value).to eq("000000780000007800000078")
+        expect(x.encoded).to eq(true)
       end
 
       # constants
@@ -126,7 +136,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("ABS")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "acosExpression"}.expression.tap do |x|
@@ -135,7 +146,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("ACOS")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "asinExpression"}.expression.tap do |x|
@@ -144,7 +156,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("ASIN")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "atanExpression"}.expression.tap do |x|
@@ -153,7 +166,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("ATAN")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "blengthExpression"}.expression.tap do |x|
@@ -162,7 +176,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("BLENGTH")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "cosExpression"}.expression.tap do |x|
@@ -171,7 +186,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("COS")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "existsExpression"}.expression.tap do |x|
@@ -180,7 +196,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("EXISTS")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "expExpression"}.expression.tap do |x|
@@ -189,7 +206,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("EXP")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "formatExpression"}.expression.tap do |x|
@@ -198,7 +216,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("FORMAT")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "hiboundExpression"}.expression.tap do |x|
@@ -207,7 +226,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("HIBOUND")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "hiindexExpression"}.expression.tap do |x|
@@ -216,7 +236,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("HIINDEX")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "lengthExpression"}.expression.tap do |x|
@@ -225,7 +246,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("LENGTH")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "loboundExpression"}.expression.tap do |x|
@@ -234,7 +256,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("LOBOUND")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "loindexExpression"}.expression.tap do |x|
@@ -243,7 +266,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("LOINDEX")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "logExpression"}.expression.tap do |x|
@@ -252,7 +276,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("LOG")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "log2Expression"}.expression.tap do |x|
@@ -261,7 +286,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("LOG2")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "log10Expression"}.expression.tap do |x|
@@ -270,7 +296,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("LOG10")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "nvlExpression"}.expression.tap do |x|
@@ -279,7 +306,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("NVL")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "oddExpression"}.expression.tap do |x|
@@ -288,7 +316,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("ODD")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "rolesofExpression"}.expression.tap do |x|
@@ -297,7 +326,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("ROLESOF")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "sinExpression"}.expression.tap do |x|
@@ -306,7 +336,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("SIN")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "sizeofExpression"}.expression.tap do |x|
@@ -315,7 +346,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("SIZEOF")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "sqrtExpression"}.expression.tap do |x|
@@ -324,7 +356,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("SQRT")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "tanExpression"}.expression.tap do |x|
@@ -333,7 +366,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("TAN")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "typeofExpression"}.expression.tap do |x|
@@ -342,7 +376,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("TYPEOF")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "usedinExpression"}.expression.tap do |x|
@@ -351,7 +386,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("USEDIN")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "valueExpression"}.expression.tap do |x|
@@ -360,7 +396,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("VALUE")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "valueInExpression"}.expression.tap do |x|
@@ -369,7 +406,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("VALUE_IN")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "valueUniqueExpression"}.expression.tap do |x|
@@ -378,7 +416,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.function.id).to eq("VALUE_UNIQUE")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       # operations
@@ -387,7 +426,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::UnaryPlus)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(1)
-        expect(x.operands[0]).to eq(4)
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].value).to eq("4")
       end
 
       constants.find{|x| x.id == "unaryMinusExpression"}.expression.tap do |x|
@@ -395,7 +435,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::UnaryMinus)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(1)
-        expect(x.operands[0]).to eq(4)
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].value).to eq("4")
       end
 
       constants.find{|x| x.id == "additionExpression"}.expression.tap do |x|
@@ -403,8 +444,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::Addition)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(2)
-        expect(x.operands[0]).to eq(4)
-        expect(x.operands[1]).to eq(2)
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].value).to eq("4")
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].value).to eq("2")
       end
 
       constants.find{|x| x.id == "subtractionExpression"}.expression.tap do |x|
@@ -412,8 +455,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::Subtraction)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(2)
-        expect(x.operands[0]).to eq(4)
-        expect(x.operands[1]).to eq(2)
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].value).to eq("4")
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].value).to eq("2")
       end
 
       constants.find{|x| x.id == "multiplicationExpression"}.expression.tap do |x|
@@ -421,8 +466,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::Multiplication)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(2)
-        expect(x.operands[0]).to eq(4)
-        expect(x.operands[1]).to eq(2)
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].value).to eq("4")
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].value).to eq("2")
       end
 
       constants.find{|x| x.id == "realDivisionExpression"}.expression.tap do |x|
@@ -430,8 +477,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::RealDivision)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(2)
-        expect(x.operands[0]).to eq(4)
-        expect(x.operands[1]).to eq(2)
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].value).to eq("4")
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].value).to eq("2")
       end
 
       constants.find{|x| x.id == "integerDivisionExpression"}.expression.tap do |x|
@@ -439,8 +488,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::IntegerDivision)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(2)
-        expect(x.operands[0]).to eq(4)
-        expect(x.operands[1]).to eq(2)
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].value).to eq("4")
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].value).to eq("2")
       end
 
       constants.find{|x| x.id == "moduloExpression"}.expression.tap do |x|
@@ -448,8 +499,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::Modulo)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(2)
-        expect(x.operands[0]).to eq(4)
-        expect(x.operands[1]).to eq(2)
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].value).to eq("4")
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].value).to eq("2")
       end
 
       constants.find{|x| x.id == "exponentiationExpression"}.expression.tap do |x|
@@ -457,8 +510,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::Exponentiation)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(2)
-        expect(x.operands[0]).to eq(4)
-        expect(x.operands[1]).to eq(2)
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].value).to eq("4")
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].value).to eq("2")
       end
 
       constants.find{|x| x.id == "additionAdditionExpression"}.expression.tap do |x|
@@ -470,9 +525,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Addition)
         expect(x.operands[0].operands).to be_instance_of(Array)
         expect(x.operands[0].operands.count).to eq(2)
-        expect(x.operands[0].operands[0]).to eq(4)
-        expect(x.operands[0].operands[1]).to eq(2)
-        expect(x.operands[1]).to eq(1)
+        expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].operands[0].value).to eq("4")
+        expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].operands[1].value).to eq("2")
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].value).to eq("1")
       end
 
       constants.find{|x| x.id == "subtractionSubtractionExpression"}.expression.tap do |x|
@@ -484,9 +542,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Subtraction)
         expect(x.operands[0].operands).to be_instance_of(Array)
         expect(x.operands[0].operands.count).to eq(2)
-        expect(x.operands[0].operands[0]).to eq(4)
-        expect(x.operands[0].operands[1]).to eq(2)
-        expect(x.operands[1]).to eq(1)
+        expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].operands[0].value).to eq("4")
+        expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].operands[1].value).to eq("2")
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].value).to eq("1")
       end
 
       constants.find{|x| x.id == "additionSubtractionExpression"}.expression.tap do |x|
@@ -498,9 +559,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Addition)
         expect(x.operands[0].operands).to be_instance_of(Array)
         expect(x.operands[0].operands.count).to eq(2)
-        expect(x.operands[0].operands[0]).to eq(4)
-        expect(x.operands[0].operands[1]).to eq(2)
-        expect(x.operands[1]).to eq(1)
+        expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].operands[0].value).to eq("4")
+        expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].operands[1].value).to eq("2")
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].value).to eq("1")
       end
 
       constants.find{|x| x.id == "subtractionAdditionExpression"}.expression.tap do |x|
@@ -512,9 +576,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Subtraction)
         expect(x.operands[0].operands).to be_instance_of(Array)
         expect(x.operands[0].operands.count).to eq(2)
-        expect(x.operands[0].operands[0]).to eq(4)
-        expect(x.operands[0].operands[1]).to eq(2)
-        expect(x.operands[1]).to eq(1)
+        expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].operands[0].value).to eq("4")
+        expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].operands[1].value).to eq("2")
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].value).to eq("1")
       end
 
       constants.find{|x| x.id == "additionMultiplicationExpression"}.expression.tap do |x|
@@ -522,13 +589,16 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::Addition)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(2)
-        expect(x.operands[0]).to eq(8)
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].value).to eq("8")
         expect(x.operands[1]).to be_instance_of(Expressir::Model::Expressions::Expression)
         expect(x.operands[1].operator).to be_instance_of(Expressir::Model::Operators::Multiplication)
         expect(x.operands[1].operands).to be_instance_of(Array)
         expect(x.operands[1].operands.count).to eq(2)
-        expect(x.operands[1].operands[0]).to eq(4)
-        expect(x.operands[1].operands[1]).to eq(2)
+        expect(x.operands[1].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].operands[0].value).to eq("4")
+        expect(x.operands[1].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].operands[1].value).to eq("2")
       end
 
       constants.find{|x| x.id == "multiplicationAdditionExpression"}.expression.tap do |x|
@@ -540,9 +610,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Multiplication)
         expect(x.operands[0].operands).to be_instance_of(Array)
         expect(x.operands[0].operands.count).to eq(2)
-        expect(x.operands[0].operands[0]).to eq(8)
-        expect(x.operands[0].operands[1]).to eq(4)
-        expect(x.operands[1]).to eq(2)
+        expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].operands[0].value).to eq("8")
+        expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].operands[1].value).to eq("4")
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].value).to eq("2")
       end
 
       constants.find{|x| x.id == "parenthesisAdditionMultiplicationExpression"}.expression.tap do |x|
@@ -554,9 +627,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Addition)
         expect(x.operands[0].operands).to be_instance_of(Array)
         expect(x.operands[0].operands.count).to eq(2)
-        expect(x.operands[0].operands[0]).to eq(8)
-        expect(x.operands[0].operands[1]).to eq(4)
-        expect(x.operands[1]).to eq(2)
+        expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].operands[0].value).to eq("8")
+        expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].operands[1].value).to eq("4")
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].value).to eq("2")
       end
 
       constants.find{|x| x.id == "multiplicationParenthesisAdditionExpression"}.expression.tap do |x|
@@ -564,13 +640,16 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::Multiplication)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(2)
-        expect(x.operands[0]).to eq(8)
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].value).to eq("8")
         expect(x.operands[1]).to be_instance_of(Expressir::Model::Expressions::Expression)
         expect(x.operands[1].operator).to be_instance_of(Expressir::Model::Operators::Addition)
         expect(x.operands[1].operands).to be_instance_of(Array)
         expect(x.operands[1].operands.count).to eq(2)
-        expect(x.operands[1].operands[0]).to eq(4)
-        expect(x.operands[1].operands[1]).to eq(2)
+        expect(x.operands[1].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].operands[0].value).to eq("4")
+        expect(x.operands[1].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].operands[1].value).to eq("2")
       end
 
       constants.find{|x| x.id == "equalExpression"}.expression.tap do |x|
@@ -578,8 +657,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::Equal)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(2)
-        expect(x.operands[0]).to eq(4)
-        expect(x.operands[1]).to eq(2)
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].value).to eq("4")
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].value).to eq("2")
       end
 
       constants.find{|x| x.id == "notEqualExpression"}.expression.tap do |x|
@@ -587,8 +668,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::NotEqual)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(2)
-        expect(x.operands[0]).to eq(4)
-        expect(x.operands[1]).to eq(2)
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].value).to eq("4")
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].value).to eq("2")
       end
 
       constants.find{|x| x.id == "ltExpression"}.expression.tap do |x|
@@ -596,8 +679,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::LessThan)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(2)
-        expect(x.operands[0]).to eq(4)
-        expect(x.operands[1]).to eq(2)
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].value).to eq("4")
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].value).to eq("2")
       end
 
       constants.find{|x| x.id == "gtExpression"}.expression.tap do |x|
@@ -605,8 +690,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::GreaterThan)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(2)
-        expect(x.operands[0]).to eq(4)
-        expect(x.operands[1]).to eq(2)
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].value).to eq("4")
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].value).to eq("2")
       end
 
       constants.find{|x| x.id == "lteExpression"}.expression.tap do |x|
@@ -614,8 +701,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::LessThanOrEqual)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(2)
-        expect(x.operands[0]).to eq(4)
-        expect(x.operands[1]).to eq(2)
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].value).to eq("4")
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].value).to eq("2")
       end
 
       constants.find{|x| x.id == "gteExpression"}.expression.tap do |x|
@@ -623,8 +712,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::GreaterThanOrEqual)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(2)
-        expect(x.operands[0]).to eq(4)
-        expect(x.operands[1]).to eq(2)
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[0].value).to eq("4")
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.operands[1].value).to eq("2")
       end
 
       constants.find{|x| x.id == "orExpression"}.expression.tap do |x|
@@ -632,8 +723,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::Or)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(2)
-        expect(x.operands[0]).to eq(true)
-        expect(x.operands[1]).to eq(false)
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[0].value).to eq(true)
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[1].value).to eq(false)
       end
 
       constants.find{|x| x.id == "andExpression"}.expression.tap do |x|
@@ -641,20 +734,27 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::And)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(2)
-        expect(x.operands[0]).to eq(true)
-        expect(x.operands[1]).to eq(false)
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[0].value).to eq(true)
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[1].value).to eq(false)
       end
 
       constants.find{|x| x.id == "orOrExpression"}.expression.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::Or)
+        expect(x.operands).to be_instance_of(Array)
+        expect(x.operands.count).to eq(2)
         expect(x.operands[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
         expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Or)
         expect(x.operands[0].operands).to be_instance_of(Array)
         expect(x.operands[0].operands.count).to eq(2)
-        expect(x.operands[0].operands[0]).to eq(true)
-        expect(x.operands[0].operands[1]).to eq(false)
-        expect(x.operands[1]).to eq(true)
+        expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[0].operands[0].value).to eq(true)
+        expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[0].operands[1].value).to eq(false)
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[1].value).to eq(true)
       end
 
       constants.find{|x| x.id == "andAndExpression"}.expression.tap do |x|
@@ -666,9 +766,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::And)
         expect(x.operands[0].operands).to be_instance_of(Array)
         expect(x.operands[0].operands.count).to eq(2)
-        expect(x.operands[0].operands[0]).to eq(true)
-        expect(x.operands[0].operands[1]).to eq(false)
-        expect(x.operands[1]).to eq(true)
+        expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[0].operands[0].value).to eq(true)
+        expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[0].operands[1].value).to eq(false)
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[1].value).to eq(true)
       end
 
       constants.find{|x| x.id == "orAndExpression"}.expression.tap do |x|
@@ -676,13 +779,16 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::Or)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(2)
-        expect(x.operands[0]).to eq(true)
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[0].value).to eq(true)
         expect(x.operands[1]).to be_instance_of(Expressir::Model::Expressions::Expression)
         expect(x.operands[1].operator).to be_instance_of(Expressir::Model::Operators::And)
         expect(x.operands[1].operands).to be_instance_of(Array)
         expect(x.operands[1].operands.count).to eq(2)
-        expect(x.operands[1].operands[0]).to eq(false)
-        expect(x.operands[1].operands[1]).to eq(true)
+        expect(x.operands[1].operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[1].operands[0].value).to eq(false)
+        expect(x.operands[1].operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[1].operands[1].value).to eq(true)
       end
 
       constants.find{|x| x.id == "andOrExpression"}.expression.tap do |x|
@@ -694,9 +800,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::And)
         expect(x.operands[0].operands).to be_instance_of(Array)
         expect(x.operands[0].operands.count).to eq(2)
-        expect(x.operands[0].operands[0]).to eq(true)
-        expect(x.operands[0].operands[1]).to eq(false)
-        expect(x.operands[1]).to eq(true)
+        expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[0].operands[0].value).to eq(true)
+        expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[0].operands[1].value).to eq(false)
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[1].value).to eq(true)
       end
 
       constants.find{|x| x.id == "parenthesisOrAndExpression"}.expression.tap do |x|
@@ -708,9 +817,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Or)
         expect(x.operands[0].operands).to be_instance_of(Array)
         expect(x.operands[0].operands.count).to eq(2)
-        expect(x.operands[0].operands[0]).to eq(true)
-        expect(x.operands[0].operands[1]).to eq(false)
-        expect(x.operands[1]).to eq(true)
+        expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[0].operands[0].value).to eq(true)
+        expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[0].operands[1].value).to eq(false)
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[1].value).to eq(true)
       end
 
       constants.find{|x| x.id == "andParenthesisOrExpression"}.expression.tap do |x|
@@ -718,57 +830,73 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::And)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(2)
-        expect(x.operands[0]).to eq(true)
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[0].value).to eq(true)
         expect(x.operands[1]).to be_instance_of(Expressir::Model::Expressions::Expression)
         expect(x.operands[1].operator).to be_instance_of(Expressir::Model::Operators::Or)
         expect(x.operands[1].operands).to be_instance_of(Array)
         expect(x.operands[1].operands.count).to eq(2)
-        expect(x.operands[1].operands[0]).to eq(false)
-        expect(x.operands[1].operands[1]).to eq(true)
+        expect(x.operands[1].operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[1].operands[0].value).to eq(false)
+        expect(x.operands[1].operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[1].operands[1].value).to eq(true)
       end
 
       # aggregate initializers
-      constants.find{|x| x.id == "aggregateExpression"}.expression.tap do |x|
-        expect(x).to be_instance_of(Array)
-        expect(x.count).to eq(1)
-        expect(x[0]).to eq("xxx")
-      end
-
-      constants.find{|x| x.id == "aggregateRepeatedExpression"}.expression.tap do |x|
-        expect(x).to be_instance_of(Array)
-        expect(x.count).to eq(1)
-        expect(x[0]).to be_instance_of(Expressir::Model::Expressions::AggregateElement)
-        expect(x[0].expression).to eq("xxx")
-        expect(x[0].repetition).to eq(2)
-      end
-
-      constants.find{|x| x.id == "aggregateComplexExpression"}.expression.tap do |x|
-        expect(x).to be_instance_of(Array)
-        expect(x.count).to eq(1)
-        expect(x[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x[0].operator).to be_instance_of(Expressir::Model::Operators::Addition)
-        expect(x[0].operands).to be_instance_of(Array)
-        expect(x[0].operands.count).to eq(2)
-        expect(x[0].operands[0]).to eq(4)
-        expect(x[0].operands[1]).to eq(2)
-      end
-
-      constants.find{|x| x.id == "aggregateComplexRepeatedExpression"}.expression.tap do |x|
-        expect(x).to be_instance_of(Array)
-        expect(x.count).to eq(1)
-        expect(x[0]).to be_instance_of(Expressir::Model::Expressions::AggregateElement)
-        expect(x[0].expression).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x[0].expression.operator).to be_instance_of(Expressir::Model::Operators::Addition)
-        expect(x[0].expression.operands).to be_instance_of(Array)
-        expect(x[0].expression.operands.count).to eq(2)
-        expect(x[0].expression.operands[0]).to eq(4)
-        expect(x[0].expression.operands[1]).to eq(2)
-        expect(x[0].repetition).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x[0].repetition.operator).to be_instance_of(Expressir::Model::Operators::Addition)
-        expect(x[0].repetition.operands).to be_instance_of(Array)
-        expect(x[0].repetition.operands.count).to eq(2)
-        expect(x[0].repetition.operands[0]).to eq(4)
-        expect(x[0].repetition.operands[1]).to eq(2)
+      constants.find{|x| x.id == "aggregateInitializerExpression"}.expression.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Expressions::AggregateInitializer)
+        expect(x.items).to be_instance_of(Array)
+        expect(x.items.count).to eq(1)
+        expect(x.items[0]).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.items[0].value).to eq("xxx")
+      end
+
+      constants.find{|x| x.id == "repeatedAggregateInitializerExpression"}.expression.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Expressions::AggregateInitializer)
+        expect(x.items).to be_instance_of(Array)
+        expect(x.items.count).to eq(1)
+        expect(x.items[0]).to be_instance_of(Expressir::Model::Expressions::AggregateElement)
+        expect(x.items[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.items[0].expression.value).to eq("xxx")
+        expect(x.items[0].repetition).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.items[0].repetition.value).to eq("2")
+      end
+
+      constants.find{|x| x.id == "complexAggregateInitializerExpression"}.expression.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Expressions::AggregateInitializer)
+        expect(x.items).to be_instance_of(Array)
+        expect(x.items.count).to eq(1)
+        expect(x.items[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
+        expect(x.items[0].operator).to be_instance_of(Expressir::Model::Operators::Addition)
+        expect(x.items[0].operands).to be_instance_of(Array)
+        expect(x.items[0].operands.count).to eq(2)
+        expect(x.items[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.items[0].operands[0].value).to eq("4")
+        expect(x.items[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.items[0].operands[1].value).to eq("2")
+      end
+
+      constants.find{|x| x.id == "complexRepeatedAggregateInitializerExpression"}.expression.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Expressions::AggregateInitializer)
+        expect(x.items).to be_instance_of(Array)
+        expect(x.items.count).to eq(1)
+        expect(x.items[0]).to be_instance_of(Expressir::Model::Expressions::AggregateElement)
+        expect(x.items[0].expression).to be_instance_of(Expressir::Model::Expressions::Expression)
+        expect(x.items[0].expression.operator).to be_instance_of(Expressir::Model::Operators::Addition)
+        expect(x.items[0].expression.operands).to be_instance_of(Array)
+        expect(x.items[0].expression.operands.count).to eq(2)
+        expect(x.items[0].expression.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.items[0].expression.operands[0].value).to eq("4")
+        expect(x.items[0].expression.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.items[0].expression.operands[1].value).to eq("2")
+        expect(x.items[0].repetition).to be_instance_of(Expressir::Model::Expressions::Expression)
+        expect(x.items[0].repetition.operator).to be_instance_of(Expressir::Model::Operators::Addition)
+        expect(x.items[0].repetition.operands).to be_instance_of(Array)
+        expect(x.items[0].repetition.operands.count).to eq(2)
+        expect(x.items[0].repetition.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.items[0].repetition.operands[0].value).to eq("4")
+        expect(x.items[0].repetition.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.items[0].repetition.operands[1].value).to eq("2")
       end
 
       # entity constructors
@@ -778,7 +906,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.entity.id).to eq("explicitAttributeEntity")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       # enumeration references
@@ -801,38 +930,50 @@ RSpec.describe Expressir::ExpressExp::Parser do
       # intervals
       constants.find{|x| x.id == "ltLtIntervalExpression"}.expression.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Expressions::Interval)
-        expect(x.low).to eq(1)
+        expect(x.low).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.low.value).to eq("1")
         expect(x.operator1).to be_instance_of(Expressir::Model::Operators::LessThan)
-        expect(x.item).to eq(5)
+        expect(x.item).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.item.value).to eq("5")
         expect(x.operator2).to be_instance_of(Expressir::Model::Operators::LessThan)
-        expect(x.high).to eq(9)
+        expect(x.high).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.high.value).to eq("9")
       end
 
       constants.find{|x| x.id == "lteLtIntervalExpression"}.expression.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Expressions::Interval)
-        expect(x.low).to eq(1)
+        expect(x.low).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.low.value).to eq("1")
         expect(x.operator1).to be_instance_of(Expressir::Model::Operators::LessThanOrEqual)
-        expect(x.item).to eq(5)
+        expect(x.item).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.item.value).to eq("5")
         expect(x.operator2).to be_instance_of(Expressir::Model::Operators::LessThan)
-        expect(x.high).to eq(9)
+        expect(x.high).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.high.value).to eq("9")
       end
 
       constants.find{|x| x.id == "ltLteIntervalExpression"}.expression.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Expressions::Interval)
-        expect(x.low).to eq(1)
+        expect(x.low).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.low.value).to eq("1")
         expect(x.operator1).to be_instance_of(Expressir::Model::Operators::LessThan)
-        expect(x.item).to eq(5)
+        expect(x.item).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.item.value).to eq("5")
         expect(x.operator2).to be_instance_of(Expressir::Model::Operators::LessThanOrEqual)
-        expect(x.high).to eq(9)
+        expect(x.high).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.high.value).to eq("9")
       end
 
       constants.find{|x| x.id == "lteLteIntervalExpression"}.expression.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Expressions::Interval)
-        expect(x.low).to eq(1)
+        expect(x.low).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.low.value).to eq("1")
         expect(x.operator1).to be_instance_of(Expressir::Model::Operators::LessThanOrEqual)
-        expect(x.item).to eq(5)
+        expect(x.item).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.item.value).to eq("5")
         expect(x.operator2).to be_instance_of(Expressir::Model::Operators::LessThanOrEqual)
-        expect(x.high).to eq(9)
+        expect(x.high).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.high.value).to eq("9")
       end
 
       constants.find{|x| x.id == "combineExpression"}.expression.tap do |x|
@@ -851,10 +992,13 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::In)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(2)
-        expect(x.operands[0]).to eq(true)
-        expect(x.operands[1]).to be_instance_of(Array)
-        expect(x.operands[1].count).to eq(1)
-        expect(x.operands[1][0]).to eq(true)
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[0].value).to eq(true)
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Expressions::AggregateInitializer)
+        expect(x.operands[1].items).to be_instance_of(Array)
+        expect(x.operands[1].items.count).to eq(1)
+        expect(x.operands[1].items[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.operands[1].items[0].value).to eq(true)
       end
 
       constants.find{|x| x.id == "likeExpression"}.expression.tap do |x|
@@ -862,8 +1006,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.operator).to be_instance_of(Expressir::Model::Operators::Like)
         expect(x.operands).to be_instance_of(Array)
         expect(x.operands.count).to eq(2)
-        expect(x.operands[0]).to eq("xxx")
-        expect(x.operands[1]).to eq("xxx")
+        expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.operands[0].value).to eq("xxx")
+        expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.operands[1].value).to eq("xxx")
       end
 
       # queries
@@ -872,7 +1018,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.id).to eq("test")
         expect(x.source).to be_instance_of(Expressir::Model::Ref)
         expect(x.source.id).to eq("test2")
-        expect(x.expression).to eq(true)
+        expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.expression.value).to eq(true)
       end
 
       # types
@@ -887,7 +1034,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.where).to be_instance_of(Array)
         expect(x.where.count).to eq(1)
         expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
-        expect(x.where[0].expression).to eq(true)
+        expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.where[0].expression.value).to eq(true)
       end
 
       types.find{|x| x.id == "integerWhereLabelType"}.tap do |x|
@@ -897,7 +1045,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.where.count).to eq(1)
         expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
         expect(x.where[0].id).to eq("WR1")
-        expect(x.where[0].expression).to eq(true)
+        expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.where[0].expression.value).to eq(true)
       end
 
       # simple types
@@ -907,12 +1056,14 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       types.find{|x| x.id == "binaryWidthType"}.type.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Types::Binary)
-        expect(x.width).to eq(3)
+        expect(x.width).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.width.value).to eq("3")
       end
 
       types.find{|x| x.id == "binaryWidthFixedType"}.type.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Types::Binary)
-        expect(x.width).to eq(3)
+        expect(x.width).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.width.value).to eq("3")
         expect(x.fixed).to eq(true)
       end
 
@@ -938,7 +1089,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       types.find{|x| x.id == "realPrecisionType"}.type.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Types::Real)
-        expect(x.precision).to eq(3)
+        expect(x.precision).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.precision.value).to eq("3")
       end
 
       types.find{|x| x.id == "stringType"}.type.tap do |x|
@@ -947,43 +1099,53 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       types.find{|x| x.id == "stringWidthType"}.type.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.width).to eq(3)
+        expect(x.width).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.width.value).to eq("3")
       end
 
       types.find{|x| x.id == "stringWidthFixedType"}.type.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.width).to eq(3)
+        expect(x.width).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.width.value).to eq("3")
         expect(x.fixed).to eq(true)
       end
 
       # aggregation types
       types.find{|x| x.id == "arrayType"}.type.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Types::Array)
-        expect(x.bound1).to eq(1)
-        expect(x.bound2).to eq(9)
+        expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.bound1.value).to eq("1")
+        expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.bound2.value).to eq("9")
         expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
       end
 
       types.find{|x| x.id == "arrayOptionalType"}.type.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Types::Array)
-        expect(x.bound1).to eq(1)
-        expect(x.bound2).to eq(9)
+        expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.bound1.value).to eq("1")
+        expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.bound2.value).to eq("9")
         expect(x.optional).to eq(true)
         expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
       end
 
       types.find{|x| x.id == "arrayUniqueType"}.type.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Types::Array)
-        expect(x.bound1).to eq(1)
-        expect(x.bound2).to eq(9)
+        expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.bound1.value).to eq("1")
+        expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.bound2.value).to eq("9")
         expect(x.unique).to eq(true)
         expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
       end
 
       types.find{|x| x.id == "arrayOptionalUniqueType"}.type.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Types::Array)
-        expect(x.bound1).to eq(1)
-        expect(x.bound2).to eq(9)
+        expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.bound1.value).to eq("1")
+        expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.bound2.value).to eq("9")
         expect(x.optional).to eq(true)
         expect(x.unique).to eq(true)
         expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
@@ -996,8 +1158,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       types.find{|x| x.id == "bagBoundType"}.type.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Types::Bag)
-        expect(x.bound1).to eq(1)
-        expect(x.bound2).to eq(9)
+        expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.bound1.value).to eq("1")
+        expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.bound2.value).to eq("9")
         expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
       end
 
@@ -1008,8 +1172,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       types.find{|x| x.id == "listBoundType"}.type.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Types::List)
-        expect(x.bound1).to eq(1)
-        expect(x.bound2).to eq(9)
+        expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.bound1.value).to eq("1")
+        expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.bound2.value).to eq("9")
         expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
       end
 
@@ -1021,8 +1187,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       types.find{|x| x.id == "listBoundUniqueType"}.type.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Types::List)
-        expect(x.bound1).to eq(1)
-        expect(x.bound2).to eq(9)
+        expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.bound1.value).to eq("1")
+        expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.bound2.value).to eq("9")
         expect(x.unique).to eq(true)
         expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
       end
@@ -1034,8 +1202,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       types.find{|x| x.id == "setBoundType"}.type.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Types::Set)
-        expect(x.bound1).to eq(1)
-        expect(x.bound2).to eq(9)
+        expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.bound1.value).to eq("1")
+        expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.bound2.value).to eq("9")
         expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
       end
 
@@ -1057,10 +1227,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       types.find{|x| x.id == "selectListType"}.type.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Types::Select)
-        expect(x.list).to be_instance_of(Array)
-        expect(x.list.count).to eq(1)
-        expect(x.list[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.list[0].id).to eq("test")
+        expect(x.items).to be_instance_of(Array)
+        expect(x.items.count).to eq(1)
+        expect(x.items[0]).to be_instance_of(Expressir::Model::Ref)
+        expect(x.items[0].id).to eq("test")
       end
 
       types.find{|x| x.id == "selectExtensionTypeRefType"}.type.tap do |x|
@@ -1073,10 +1243,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x).to be_instance_of(Expressir::Model::Types::Select)
         expect(x.extension_type).to be_instance_of(Expressir::Model::Ref)
         expect(x.extension_type.id).to eq("selectType")
-        expect(x.extension_list).to be_instance_of(Array)
-        expect(x.extension_list.count).to eq(1)
-        expect(x.extension_list[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.extension_list[0].id).to eq("test")
+        expect(x.extension_items).to be_instance_of(Array)
+        expect(x.extension_items.count).to eq(1)
+        expect(x.extension_items[0]).to be_instance_of(Expressir::Model::Ref)
+        expect(x.extension_items[0].id).to eq("test")
       end
 
       types.find{|x| x.id == "enumerationType"}.type.tap do |x|
@@ -1090,9 +1260,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       types.find{|x| x.id == "enumerationListType"}.type.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Types::Enumeration)
-        expect(x.list).to be_instance_of(Array)
-        expect(x.list.count).to eq(1)
-        expect(x.list[0]).to eq("test")
+        expect(x.items).to be_instance_of(Array)
+        expect(x.items.count).to eq(1)
+        expect(x.items[0]).to be_instance_of(Expressir::Model::EnumerationItem)
+        expect(x.items[0].id).to eq("test")
       end
 
       types.find{|x| x.id == "enumerationExtensionTypeRefType"}.type.tap do |x|
@@ -1105,9 +1276,9 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x).to be_instance_of(Expressir::Model::Types::Enumeration)
         expect(x.extension_type).to be_instance_of(Expressir::Model::Ref)
         expect(x.extension_type.id).to eq("enumerationType")
-        expect(x.extension_list).to be_instance_of(Array)
-        expect(x.extension_list.count).to eq(1)
-        expect(x.extension_list[0]).to eq("test")
+        expect(x.extension_items).to be_instance_of(Array)
+        expect(x.extension_items[0]).to be_instance_of(Expressir::Model::EnumerationItem)
+        expect(x.extension_items[0].id).to eq("test")
       end
 
       # entities
@@ -1199,24 +1370,42 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.explicit[1].type).to be_instance_of(Expressir::Model::Types::Boolean)
       end
 
-      entities.find{|x| x.id == "explicitAttributeRenamedEntity"}.tap do |x|
+      entities.find{|x| x.id == "explicitAttributeRedeclaredEntity"}.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Entity)
+        expect(x.explicit).to be_instance_of(Array)
+        expect(x.explicit.count).to eq(1)
+        expect(x.explicit[0]).to be_instance_of(Expressir::Model::Explicit)
+        expect(x.explicit[0].supertype_attribute).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
+        expect(x.explicit[0].supertype_attribute.ref).to be_instance_of(Expressir::Model::Ref)
+        expect(x.explicit[0].supertype_attribute.ref.id).to eq("SELF")
+        expect(x.explicit[0].supertype_attribute.qualifiers).to be_instance_of(Array)
+        expect(x.explicit[0].supertype_attribute.qualifiers.count).to eq(2)
+        expect(x.explicit[0].supertype_attribute.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
+        expect(x.explicit[0].supertype_attribute.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
+        expect(x.explicit[0].supertype_attribute.qualifiers[0].entity.id).to eq("explicitAttributeEntity")
+        expect(x.explicit[0].supertype_attribute.qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
+        expect(x.explicit[0].supertype_attribute.qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
+        expect(x.explicit[0].supertype_attribute.qualifiers[1].attribute.id).to eq("test")
+        expect(x.explicit[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
+      end
+
+      entities.find{|x| x.id == "explicitAttributeRedeclaredRenamedEntity"}.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Entity)
         expect(x.explicit).to be_instance_of(Array)
         expect(x.explicit.count).to eq(1)
         expect(x.explicit[0]).to be_instance_of(Expressir::Model::Explicit)
-        expect(x.explicit[0].id).to be_instance_of(Expressir::Model::RenamedRef)
-        expect(x.explicit[0].id.ref).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
-        expect(x.explicit[0].id.ref.ref).to be_instance_of(Expressir::Model::Ref)
-        expect(x.explicit[0].id.ref.ref.id).to eq("SELF")
-        expect(x.explicit[0].id.ref.qualifiers).to be_instance_of(Array)
-        expect(x.explicit[0].id.ref.qualifiers.count).to eq(2)
-        expect(x.explicit[0].id.ref.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
-        expect(x.explicit[0].id.ref.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
-        expect(x.explicit[0].id.ref.qualifiers[0].entity.id).to eq("explicitAttributeEntity")
-        expect(x.explicit[0].id.ref.qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
-        expect(x.explicit[0].id.ref.qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
-        expect(x.explicit[0].id.ref.qualifiers[1].attribute.id).to eq("test")
-        expect(x.explicit[0].id.id).to eq("test2")
+        expect(x.explicit[0].id).to eq("test2")
+        expect(x.explicit[0].supertype_attribute).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
+        expect(x.explicit[0].supertype_attribute.ref).to be_instance_of(Expressir::Model::Ref)
+        expect(x.explicit[0].supertype_attribute.ref.id).to eq("SELF")
+        expect(x.explicit[0].supertype_attribute.qualifiers).to be_instance_of(Array)
+        expect(x.explicit[0].supertype_attribute.qualifiers.count).to eq(2)
+        expect(x.explicit[0].supertype_attribute.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
+        expect(x.explicit[0].supertype_attribute.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
+        expect(x.explicit[0].supertype_attribute.qualifiers[0].entity.id).to eq("explicitAttributeEntity")
+        expect(x.explicit[0].supertype_attribute.qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
+        expect(x.explicit[0].supertype_attribute.qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
+        expect(x.explicit[0].supertype_attribute.qualifiers[1].attribute.id).to eq("test")
         expect(x.explicit[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
       end
 
@@ -1227,7 +1416,51 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.derived[0]).to be_instance_of(Expressir::Model::Derived)
         expect(x.derived[0].id).to eq("test")
         expect(x.derived[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
-        expect(x.derived[0].expression).to eq(true)
+        expect(x.derived[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.derived[0].expression.value).to eq(true)
+      end
+
+      entities.find{|x| x.id == "derivedAttributeRedeclaredEntity"}.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Entity)
+        expect(x.derived).to be_instance_of(Array)
+        expect(x.derived.count).to eq(1)
+        expect(x.derived[0]).to be_instance_of(Expressir::Model::Derived)
+        expect(x.derived[0].supertype_attribute).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
+        expect(x.derived[0].supertype_attribute.ref).to be_instance_of(Expressir::Model::Ref)
+        expect(x.derived[0].supertype_attribute.ref.id).to eq("SELF")
+        expect(x.derived[0].supertype_attribute.qualifiers).to be_instance_of(Array)
+        expect(x.derived[0].supertype_attribute.qualifiers.count).to eq(2)
+        expect(x.derived[0].supertype_attribute.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
+        expect(x.derived[0].supertype_attribute.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
+        expect(x.derived[0].supertype_attribute.qualifiers[0].entity.id).to eq("explicitAttributeEntity")
+        expect(x.derived[0].supertype_attribute.qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
+        expect(x.derived[0].supertype_attribute.qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
+        expect(x.derived[0].supertype_attribute.qualifiers[1].attribute.id).to eq("test")
+        expect(x.derived[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
+        expect(x.derived[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.derived[0].expression.value).to eq(true)
+      end
+
+      entities.find{|x| x.id == "derivedAttributeRedeclaredRenamedEntity"}.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Entity)
+        expect(x.derived).to be_instance_of(Array)
+        expect(x.derived.count).to eq(1)
+        expect(x.derived[0]).to be_instance_of(Expressir::Model::Derived)
+        expect(x.derived[0].id).to eq("test2")
+        expect(x.derived[0].supertype_attribute).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
+        expect(x.derived[0].supertype_attribute.ref).to be_instance_of(Expressir::Model::Ref)
+        expect(x.derived[0].supertype_attribute.ref.id).to eq("SELF")
+        expect(x.derived[0].supertype_attribute.qualifiers).to be_instance_of(Array)
+        expect(x.derived[0].supertype_attribute.qualifiers.count).to eq(2)
+        expect(x.derived[0].supertype_attribute.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
+        expect(x.derived[0].supertype_attribute.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
+        expect(x.derived[0].supertype_attribute.qualifiers[0].entity.id).to eq("explicitAttributeEntity")
+        expect(x.derived[0].supertype_attribute.qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
+        expect(x.derived[0].supertype_attribute.qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
+        expect(x.derived[0].supertype_attribute.qualifiers[1].attribute.id).to eq("test")
+        expect(x.derived[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
+        expect(x.derived[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.derived[0].expression.value).to eq(true)
       end
 
       entities.find{|x| x.id == "inverseAttributeEntity"}.tap do |x|
@@ -1280,8 +1513,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.inverse[0]).to be_instance_of(Expressir::Model::Inverse)
         expect(x.inverse[0].id).to eq("test")
         expect(x.inverse[0].type).to be_instance_of(Expressir::Model::Types::Set)
-        expect(x.inverse[0].type.bound1).to eq(1)
-        expect(x.inverse[0].type.bound2).to eq(9)
+        expect(x.inverse[0].type.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.inverse[0].type.bound1.value).to eq("1")
+        expect(x.inverse[0].type.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.inverse[0].type.bound2.value).to eq("9")
         expect(x.inverse[0].type.base_type).to be_instance_of(Expressir::Model::Ref)
         expect(x.inverse[0].type.base_type.id).to eq("explicitAttributeEntity")
         expect(x.inverse[0].attribute).to be_instance_of(Expressir::Model::Ref)
@@ -1308,14 +1543,61 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.inverse[0]).to be_instance_of(Expressir::Model::Inverse)
         expect(x.inverse[0].id).to eq("test")
         expect(x.inverse[0].type).to be_instance_of(Expressir::Model::Types::Bag)
-        expect(x.inverse[0].type.bound1).to eq(1)
-        expect(x.inverse[0].type.bound2).to eq(9)
+        expect(x.inverse[0].type.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.inverse[0].type.bound1.value).to eq("1")
+        expect(x.inverse[0].type.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.inverse[0].type.bound2.value).to eq("9")
         expect(x.inverse[0].type.base_type).to be_instance_of(Expressir::Model::Ref)
         expect(x.inverse[0].type.base_type.id).to eq("explicitAttributeEntity")
         expect(x.inverse[0].attribute).to be_instance_of(Expressir::Model::Ref)
         expect(x.inverse[0].attribute.id).to eq("test")
       end
 
+      entities.find{|x| x.id == "inverseAttributeRedeclaredEntity"}.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Entity)
+        expect(x.inverse).to be_instance_of(Array)
+        expect(x.inverse.count).to eq(1)
+        expect(x.inverse[0]).to be_instance_of(Expressir::Model::Inverse)
+        expect(x.inverse[0].supertype_attribute).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
+        expect(x.inverse[0].supertype_attribute.ref).to be_instance_of(Expressir::Model::Ref)
+        expect(x.inverse[0].supertype_attribute.ref.id).to eq("SELF")
+        expect(x.inverse[0].supertype_attribute.qualifiers).to be_instance_of(Array)
+        expect(x.inverse[0].supertype_attribute.qualifiers.count).to eq(2)
+        expect(x.inverse[0].supertype_attribute.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
+        expect(x.inverse[0].supertype_attribute.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
+        expect(x.inverse[0].supertype_attribute.qualifiers[0].entity.id).to eq("explicitAttributeEntity")
+        expect(x.inverse[0].supertype_attribute.qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
+        expect(x.inverse[0].supertype_attribute.qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
+        expect(x.inverse[0].supertype_attribute.qualifiers[1].attribute.id).to eq("test")
+        expect(x.inverse[0].type).to be_instance_of(Expressir::Model::Ref)
+        expect(x.inverse[0].type.id).to eq("explicitAttributeEntity")
+        expect(x.inverse[0].attribute).to be_instance_of(Expressir::Model::Ref)
+        expect(x.inverse[0].attribute.id).to eq("test")
+      end
+
+      entities.find{|x| x.id == "inverseAttributeRedeclaredRenamedEntity"}.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Entity)
+        expect(x.inverse).to be_instance_of(Array)
+        expect(x.inverse.count).to eq(1)
+        expect(x.inverse[0]).to be_instance_of(Expressir::Model::Inverse)
+        expect(x.inverse[0].id).to eq("test2")
+        expect(x.inverse[0].supertype_attribute).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
+        expect(x.inverse[0].supertype_attribute.ref).to be_instance_of(Expressir::Model::Ref)
+        expect(x.inverse[0].supertype_attribute.ref.id).to eq("SELF")
+        expect(x.inverse[0].supertype_attribute.qualifiers).to be_instance_of(Array)
+        expect(x.inverse[0].supertype_attribute.qualifiers.count).to eq(2)
+        expect(x.inverse[0].supertype_attribute.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
+        expect(x.inverse[0].supertype_attribute.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
+        expect(x.inverse[0].supertype_attribute.qualifiers[0].entity.id).to eq("explicitAttributeEntity")
+        expect(x.inverse[0].supertype_attribute.qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
+        expect(x.inverse[0].supertype_attribute.qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
+        expect(x.inverse[0].supertype_attribute.qualifiers[1].attribute.id).to eq("test")
+        expect(x.inverse[0].type).to be_instance_of(Expressir::Model::Ref)
+        expect(x.inverse[0].type.id).to eq("explicitAttributeEntity")
+        expect(x.inverse[0].attribute).to be_instance_of(Expressir::Model::Ref)
+        expect(x.inverse[0].attribute.id).to eq("test")
+      end
+
       entities.find{|x| x.id == "uniqueEntity"}.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Entity)
         expect(x.unique).to be_instance_of(Array)
@@ -1397,7 +1679,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.where).to be_instance_of(Array)
         expect(x.where.count).to eq(1)
         expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
-        expect(x.where[0].expression).to eq(true)
+        expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.where[0].expression.value).to eq(true)
       end
 
       entities.find{|x| x.id == "whereLabelEntity"}.tap do |x|
@@ -1406,7 +1689,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.where.count).to eq(1)
         expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
         expect(x.where[0].id).to eq("WR1")
-        expect(x.where[0].expression).to eq(true)
+        expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.where[0].expression.value).to eq(true)
       end
 
       # subtype constraints
@@ -1770,7 +2054,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.constants[0]).to be_instance_of(Expressir::Model::Constant)
         expect(x.constants[0].id).to eq("test")
         expect(x.constants[0].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.constants[0].expression).to eq("xxx")
+        expect(x.constants[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.constants[0].expression.value).to eq("xxx")
         expect(x.statements).to be_instance_of(Array)
         expect(x.statements.count).to eq(1)
         expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -1784,11 +2069,13 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.constants[0]).to be_instance_of(Expressir::Model::Constant)
         expect(x.constants[0].id).to eq("test")
         expect(x.constants[0].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.constants[0].expression).to eq("xxx")
+        expect(x.constants[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.constants[0].expression.value).to eq("xxx")
         expect(x.constants[1]).to be_instance_of(Expressir::Model::Constant)
         expect(x.constants[1].id).to eq("test2")
         expect(x.constants[1].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.constants[1].expression).to eq("xxx")
+        expect(x.constants[1].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.constants[1].expression.value).to eq("xxx")
         expect(x.statements).to be_instance_of(Array)
         expect(x.statements.count).to eq(1)
         expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -1847,7 +2134,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
         expect(x.locals[0].id).to eq("test")
         expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.locals[0].expression).to eq("xxx")
+        expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.locals[0].expression.value).to eq("xxx")
         expect(x.statements).to be_instance_of(Array)
         expect(x.statements.count).to eq(1)
         expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -1861,11 +2149,13 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
         expect(x.locals[0].id).to eq("test")
         expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.locals[0].expression).to eq("xxx")
+        expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.locals[0].expression.value).to eq("xxx")
         expect(x.locals[1]).to be_instance_of(Expressir::Model::Local)
         expect(x.locals[1].id).to eq("test2")
         expect(x.locals[1].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.locals[1].expression).to eq("xxx")
+        expect(x.locals[1].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.locals[1].expression.value).to eq("xxx")
         expect(x.statements).to be_instance_of(Array)
         expect(x.statements.count).to eq(1)
         expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -1879,11 +2169,13 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
         expect(x.locals[0].id).to eq("test")
         expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.locals[0].expression).to eq("xxx")
+        expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.locals[0].expression.value).to eq("xxx")
         expect(x.locals[1]).to be_instance_of(Expressir::Model::Local)
         expect(x.locals[1].id).to eq("test2")
         expect(x.locals[1].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.locals[1].expression).to eq("xxx")
+        expect(x.locals[1].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.locals[1].expression.value).to eq("xxx")
         expect(x.statements).to be_instance_of(Array)
         expect(x.statements.count).to eq(1)
         expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2000,7 +2292,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.constants[0]).to be_instance_of(Expressir::Model::Constant)
         expect(x.constants[0].id).to eq("test")
         expect(x.constants[0].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.constants[0].expression).to eq("xxx")
+        expect(x.constants[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.constants[0].expression.value).to eq("xxx")
       end
 
       procedures.find{|x| x.id == "multipleConstantProcedure"}.tap do |x|
@@ -2010,11 +2303,13 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.constants[0]).to be_instance_of(Expressir::Model::Constant)
         expect(x.constants[0].id).to eq("test")
         expect(x.constants[0].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.constants[0].expression).to eq("xxx")
+        expect(x.constants[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.constants[0].expression.value).to eq("xxx")
         expect(x.constants[1]).to be_instance_of(Expressir::Model::Constant)
         expect(x.constants[1].id).to eq("test2")
         expect(x.constants[1].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.constants[1].expression).to eq("xxx")
+        expect(x.constants[1].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.constants[1].expression.value).to eq("xxx")
       end
 
       procedures.find{|x| x.id == "localProcedure"}.tap do |x|
@@ -2057,7 +2352,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
         expect(x.locals[0].id).to eq("test")
         expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.locals[0].expression).to eq("xxx")
+        expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.locals[0].expression.value).to eq("xxx")
       end
 
       procedures.find{|x| x.id == "multipleLocalExpressionProcedure"}.tap do |x|
@@ -2067,11 +2363,13 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
         expect(x.locals[0].id).to eq("test")
         expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.locals[0].expression).to eq("xxx")
+        expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.locals[0].expression.value).to eq("xxx")
         expect(x.locals[1]).to be_instance_of(Expressir::Model::Local)
         expect(x.locals[1].id).to eq("test2")
         expect(x.locals[1].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.locals[1].expression).to eq("xxx")
+        expect(x.locals[1].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.locals[1].expression.value).to eq("xxx")
       end
 
       procedures.find{|x| x.id == "multipleShorthandLocalExpressionProcedure"}.tap do |x|
@@ -2081,11 +2379,13 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
         expect(x.locals[0].id).to eq("test")
         expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.locals[0].expression).to eq("xxx")
+        expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.locals[0].expression.value).to eq("xxx")
         expect(x.locals[1]).to be_instance_of(Expressir::Model::Local)
         expect(x.locals[1].id).to eq("test2")
         expect(x.locals[1].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.locals[1].expression).to eq("xxx")
+        expect(x.locals[1].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.locals[1].expression.value).to eq("xxx")
       end
 
       # rules
@@ -2098,7 +2398,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.where).to be_instance_of(Array)
         expect(x.where.count).to eq(1)
         expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
-        expect(x.where[0].expression).to eq(true)
+        expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.where[0].expression.value).to eq(true)
       end
 
       rules.find{|x| x.id == "typeRule"}.tap do |x|
@@ -2115,7 +2416,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.where).to be_instance_of(Array)
         expect(x.where.count).to eq(1)
         expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
-        expect(x.where[0].expression).to eq(true)
+        expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.where[0].expression.value).to eq(true)
       end
 
       rules.find{|x| x.id == "constantRule"}.tap do |x|
@@ -2129,11 +2431,13 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.constants[0]).to be_instance_of(Expressir::Model::Constant)
         expect(x.constants[0].id).to eq("test")
         expect(x.constants[0].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.constants[0].expression).to eq("xxx")
+        expect(x.constants[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.constants[0].expression.value).to eq("xxx")
         expect(x.where).to be_instance_of(Array)
         expect(x.where.count).to eq(1)
         expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
-        expect(x.where[0].expression).to eq(true)
+        expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.where[0].expression.value).to eq(true)
       end
 
       rules.find{|x| x.id == "multipleConstantRule"}.tap do |x|
@@ -2147,15 +2451,18 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.constants[0]).to be_instance_of(Expressir::Model::Constant)
         expect(x.constants[0].id).to eq("test")
         expect(x.constants[0].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.constants[0].expression).to eq("xxx")
+        expect(x.constants[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.constants[0].expression.value).to eq("xxx")
         expect(x.constants[1]).to be_instance_of(Expressir::Model::Constant)
         expect(x.constants[1].id).to eq("test2")
         expect(x.constants[1].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.constants[1].expression).to eq("xxx")
+        expect(x.constants[1].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.constants[1].expression.value).to eq("xxx")
         expect(x.where).to be_instance_of(Array)
         expect(x.where.count).to eq(1)
         expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
-        expect(x.where[0].expression).to eq(true)
+        expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.where[0].expression.value).to eq(true)
       end
 
       rules.find{|x| x.id == "localRule"}.tap do |x|
@@ -2172,7 +2479,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.where).to be_instance_of(Array)
         expect(x.where.count).to eq(1)
         expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
-        expect(x.where[0].expression).to eq(true)
+        expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.where[0].expression.value).to eq(true)
       end
 
       rules.find{|x| x.id == "multipleLocalRule"}.tap do |x|
@@ -2192,7 +2500,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.where).to be_instance_of(Array)
         expect(x.where.count).to eq(1)
         expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
-        expect(x.where[0].expression).to eq(true)
+        expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.where[0].expression.value).to eq(true)
       end
 
       rules.find{|x| x.id == "multipleShorthandLocalRule"}.tap do |x|
@@ -2212,7 +2521,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.where).to be_instance_of(Array)
         expect(x.where.count).to eq(1)
         expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
-        expect(x.where[0].expression).to eq(true)
+        expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.where[0].expression.value).to eq(true)
       end
 
       rules.find{|x| x.id == "localExpressionRule"}.tap do |x|
@@ -2226,11 +2536,13 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
         expect(x.locals[0].id).to eq("test")
         expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.locals[0].expression).to eq("xxx")
+        expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.locals[0].expression.value).to eq("xxx")
         expect(x.where).to be_instance_of(Array)
         expect(x.where.count).to eq(1)
         expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
-        expect(x.where[0].expression).to eq(true)
+        expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.where[0].expression.value).to eq(true)
       end
 
       rules.find{|x| x.id == "multipleLocalExpressionRule"}.tap do |x|
@@ -2244,15 +2556,18 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
         expect(x.locals[0].id).to eq("test")
         expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.locals[0].expression).to eq("xxx")
+        expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.locals[0].expression.value).to eq("xxx")
         expect(x.locals[1]).to be_instance_of(Expressir::Model::Local)
         expect(x.locals[1].id).to eq("test2")
         expect(x.locals[1].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.locals[1].expression).to eq("xxx")
+        expect(x.locals[1].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.locals[1].expression.value).to eq("xxx")
         expect(x.where).to be_instance_of(Array)
         expect(x.where.count).to eq(1)
         expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
-        expect(x.where[0].expression).to eq(true)
+        expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.where[0].expression.value).to eq(true)
       end
 
       rules.find{|x| x.id == "multipleShorthandLocalExpressionRule"}.tap do |x|
@@ -2266,15 +2581,18 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
         expect(x.locals[0].id).to eq("test")
         expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.locals[0].expression).to eq("xxx")
+        expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.locals[0].expression.value).to eq("xxx")
         expect(x.locals[1]).to be_instance_of(Expressir::Model::Local)
         expect(x.locals[1].id).to eq("test2")
         expect(x.locals[1].type).to be_instance_of(Expressir::Model::Types::String)
-        expect(x.locals[1].expression).to eq("xxx")
+        expect(x.locals[1].expression).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.locals[1].expression.value).to eq("xxx")
         expect(x.where).to be_instance_of(Array)
         expect(x.where.count).to eq(1)
         expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
-        expect(x.where[0].expression).to eq(true)
+        expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.where[0].expression.value).to eq(true)
       end
 
       # statements
@@ -2329,7 +2647,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.expression.qualifiers).to be_instance_of(Array)
         expect(x.expression.qualifiers.count).to eq(1)
         expect(x.expression.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::IndexQualifier)
-        expect(x.expression.qualifiers[0].index1).to eq(1)
+        expect(x.expression.qualifiers[0].index1).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.expression.qualifiers[0].index1.value).to eq("1")
         expect(x.statements).to be_instance_of(Array)
         expect(x.statements.count).to eq(1)
         expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2344,8 +2663,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.expression.qualifiers).to be_instance_of(Array)
         expect(x.expression.qualifiers.count).to eq(1)
         expect(x.expression.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::IndexQualifier)
-        expect(x.expression.qualifiers[0].index1).to eq(1)
-        expect(x.expression.qualifiers[0].index2).to eq(9)
+        expect(x.expression.qualifiers[0].index1).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.expression.qualifiers[0].index1.value).to eq("1")
+        expect(x.expression.qualifiers[0].index2).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.expression.qualifiers[0].index2.value).to eq("9")
         expect(x.statements).to be_instance_of(Array)
         expect(x.statements.count).to eq(1)
         expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2355,7 +2676,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x).to be_instance_of(Expressir::Model::Statements::Assignment)
         expect(x.ref).to be_instance_of(Expressir::Model::Ref)
         expect(x.ref.id).to eq("test")
-        expect(x.expression).to eq(true)
+        expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.expression.value).to eq(true)
       end
 
       functions.find{|x| x.id == "assignmentAttributeStatement"}.statements[0].tap do |x|
@@ -2368,7 +2690,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.ref.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
         expect(x.ref.qualifiers[0].attribute).to be_instance_of(Expressir::Model::Ref)
         expect(x.ref.qualifiers[0].attribute.id).to eq("test")
-        expect(x.expression).to eq(true)
+        expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.expression.value).to eq(true)
       end
 
       functions.find{|x| x.id == "assignmentGroupStatement"}.statements[0].tap do |x|
@@ -2381,7 +2704,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.ref.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
         expect(x.ref.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
         expect(x.ref.qualifiers[0].entity.id).to eq("test")
-        expect(x.expression).to eq(true)
+        expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.expression.value).to eq(true)
       end
 
       functions.find{|x| x.id == "assignmentIndexStatement"}.statements[0].tap do |x|
@@ -2392,8 +2716,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.ref.qualifiers).to be_instance_of(Array)
         expect(x.ref.qualifiers.count).to eq(1)
         expect(x.ref.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::IndexQualifier)
-        expect(x.ref.qualifiers[0].index1).to eq(1)
-        expect(x.expression).to eq(true)
+        expect(x.ref.qualifiers[0].index1).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.ref.qualifiers[0].index1.value).to eq("1")
+        expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.expression.value).to eq(true)
       end
 
       functions.find{|x| x.id == "assignmentIndex2Statement"}.statements[0].tap do |x|
@@ -2404,9 +2730,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.ref.qualifiers).to be_instance_of(Array)
         expect(x.ref.qualifiers.count).to eq(1)
         expect(x.ref.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::IndexQualifier)
-        expect(x.ref.qualifiers[0].index1).to eq(1)
-        expect(x.ref.qualifiers[0].index2).to eq(9)
-        expect(x.expression).to eq(true)
+        expect(x.ref.qualifiers[0].index1).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.ref.qualifiers[0].index1.value).to eq("1")
+        expect(x.ref.qualifiers[0].index2).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.ref.qualifiers[0].index2.value).to eq("9")
+        expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.expression.value).to eq(true)
       end
 
       functions.find{|x| x.id == "caseStatement"}.statements[0].tap do |x|
@@ -2416,7 +2745,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.actions).to be_instance_of(Array)
         expect(x.actions.count).to eq(1)
         expect(x.actions[0]).to be_instance_of(Expressir::Model::Statements::CaseAction)
-        expect(x.actions[0].label).to eq(true)
+        expect(x.actions[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.actions[0].expression.value).to eq(true)
         expect(x.actions[0].statement).to be_instance_of(Expressir::Model::Statements::Null)
       end
 
@@ -2427,10 +2757,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.actions).to be_instance_of(Array)
         expect(x.actions.count).to eq(2)
         expect(x.actions[0]).to be_instance_of(Expressir::Model::Statements::CaseAction)
-        expect(x.actions[0].label).to eq(true)
+        expect(x.actions[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.actions[0].expression.value).to eq(true)
         expect(x.actions[0].statement).to be_instance_of(Expressir::Model::Statements::Null)
         expect(x.actions[1]).to be_instance_of(Expressir::Model::Statements::CaseAction)
-        expect(x.actions[1].label).to eq(true)
+        expect(x.actions[1].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.actions[1].expression.value).to eq(true)
         expect(x.actions[1].statement).to be_instance_of(Expressir::Model::Statements::Null)
       end
 
@@ -2441,10 +2773,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.actions).to be_instance_of(Array)
         expect(x.actions.count).to eq(2)
         expect(x.actions[0]).to be_instance_of(Expressir::Model::Statements::CaseAction)
-        expect(x.actions[0].label).to eq(true)
+        expect(x.actions[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.actions[0].expression.value).to eq(true)
         expect(x.actions[0].statement).to be_instance_of(Expressir::Model::Statements::Null)
         expect(x.actions[1]).to be_instance_of(Expressir::Model::Statements::CaseAction)
-        expect(x.actions[1].label).to eq(true)
+        expect(x.actions[1].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.actions[1].expression.value).to eq(true)
         expect(x.actions[1].statement).to be_instance_of(Expressir::Model::Statements::Null)
       end
 
@@ -2455,7 +2789,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.actions).to be_instance_of(Array)
         expect(x.actions.count).to eq(1)
         expect(x.actions[0]).to be_instance_of(Expressir::Model::Statements::CaseAction)
-        expect(x.actions[0].label).to eq(true)
+        expect(x.actions[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.actions[0].expression.value).to eq(true)
         expect(x.actions[0].statement).to be_instance_of(Expressir::Model::Statements::Null)
         expect(x.otherwise_statement).to be_instance_of(Expressir::Model::Statements::Null)
       end
@@ -2473,7 +2808,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       functions.find{|x| x.id == "ifStatement"}.statements[0].tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Statements::If)
-        expect(x.condition).to eq(true)
+        expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.expression.value).to eq(true)
         expect(x.statements).to be_instance_of(Array)
         expect(x.statements.count).to eq(1)
         expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2481,7 +2817,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       functions.find{|x| x.id == "if2Statement"}.statements[0].tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Statements::If)
-        expect(x.condition).to eq(true)
+        expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.expression.value).to eq(true)
         expect(x.statements).to be_instance_of(Array)
         expect(x.statements.count).to eq(2)
         expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2490,7 +2827,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       functions.find{|x| x.id == "ifElseStatement"}.statements[0].tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Statements::If)
-        expect(x.condition).to eq(true)
+        expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.expression.value).to eq(true)
         expect(x.statements).to be_instance_of(Array)
         expect(x.statements.count).to eq(1)
         expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2501,7 +2839,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       functions.find{|x| x.id == "if2ElseStatement"}.statements[0].tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Statements::If)
-        expect(x.condition).to eq(true)
+        expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.expression.value).to eq(true)
         expect(x.statements).to be_instance_of(Array)
         expect(x.statements.count).to eq(2)
         expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2513,7 +2852,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       functions.find{|x| x.id == "ifElse2Statement"}.statements[0].tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Statements::If)
-        expect(x.condition).to eq(true)
+        expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.expression.value).to eq(true)
         expect(x.statements).to be_instance_of(Array)
         expect(x.statements.count).to eq(1)
         expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2525,7 +2865,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       functions.find{|x| x.id == "if2Else2Statement"}.statements[0].tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Statements::If)
-        expect(x.condition).to eq(true)
+        expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.expression.value).to eq(true)
         expect(x.statements).to be_instance_of(Array)
         expect(x.statements.count).to eq(2)
         expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2552,7 +2893,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.procedure.id).to eq("emptyProcedure")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
       end
 
       functions.find{|x| x.id == "procedureCallParameter2Statement"}.statements[0].tap do |x|
@@ -2561,8 +2903,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.procedure.id).to eq("emptyProcedure")
         expect(x.parameters).to be_instance_of(Array)
         expect(x.parameters.count).to eq(2)
-        expect(x.parameters[0]).to eq(true)
-        expect(x.parameters[1]).to eq(true)
+        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[0].value).to eq(true)
+        expect(x.parameters[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.parameters[1].value).to eq(true)
       end
 
       functions.find{|x| x.id == "procedureCallInsertStatement"}.statements[0].tap do |x|
@@ -2586,9 +2930,11 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       functions.find{|x| x.id == "repeatVariableStatement"}.statements[0].tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Statements::Repeat)
-        expect(x.variable).to eq("test")
-        expect(x.bound1).to eq(1)
-        expect(x.bound2).to eq(9)
+        expect(x.id).to eq("test")
+        expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.bound1.value).to eq("1")
+        expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.bound2.value).to eq("9")
         expect(x.statements).to be_instance_of(Array)
         expect(x.statements.count).to eq(1)
         expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2596,10 +2942,13 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       functions.find{|x| x.id == "repeatVariableIncrementStatement"}.statements[0].tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Statements::Repeat)
-        expect(x.variable).to eq("test")
-        expect(x.bound1).to eq(1)
-        expect(x.bound2).to eq(9)
-        expect(x.increment).to eq(2)
+        expect(x.id).to eq("test")
+        expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.bound1.value).to eq("1")
+        expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.bound2.value).to eq("9")
+        expect(x.increment).to be_instance_of(Expressir::Model::Literals::Integer)
+        expect(x.increment.value).to eq("2")
         expect(x.statements).to be_instance_of(Array)
         expect(x.statements.count).to eq(1)
         expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2607,7 +2956,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       functions.find{|x| x.id == "repeatWhileStatement"}.statements[0].tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Statements::Repeat)
-        expect(x.while_expression).to eq(true)
+        expect(x.while_expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.while_expression.value).to eq(true)
         expect(x.statements).to be_instance_of(Array)
         expect(x.statements.count).to eq(1)
         expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2615,7 +2965,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       functions.find{|x| x.id == "repeatUntilStatement"}.statements[0].tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Statements::Repeat)
-        expect(x.until_expression).to eq(true)
+        expect(x.until_expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.until_expression.value).to eq(true)
         expect(x.statements).to be_instance_of(Array)
         expect(x.statements.count).to eq(1)
         expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2623,7 +2974,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       functions.find{|x| x.id == "returnStatement"}.statements[0].tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Statements::Return)
-        expect(x.expression).to eq(true)
+        expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.expression.value).to eq(true)
       end
 
       functions.find{|x| x.id == "skipStatement"}.statements[0].tap do |x|