@fincity/kirun-js 1.3.1 → 1.4.1

package/src/engine/json/schema/type/MultipleType.ts

@@ -4,9 +4,12 @@ import { Type } from './Type';
 export class MultipleType extends Type {
     private type: Set<SchemaType>;
 
-    constructor(type: Set<SchemaType>) {
+    public constructor(type: Set<SchemaType> | MultipleType) {
         super();
-        this.type = type;
+
+        if (type instanceof MultipleType)
+            this.type = new Set(Array.from((type as MultipleType).type));
+        else this.type = new Set(Array.from(type));
     }
 
     public getType(): Set<SchemaType> {

package/src/engine/json/schema/type/SingleType.ts

@@ -4,9 +4,11 @@ import { Type } from './Type';
 export class SingleType extends Type {
     private type: SchemaType;
 
-    constructor(type: SchemaType) {
+    public constructor(type: SchemaType | SingleType) {
         super();
-        this.type = type;
+
+        if (type instanceof SingleType) this.type = (type as SingleType).type;
+        else this.type = type as SchemaType;
     }
 
     public getType(): SchemaType {

package/src/engine/json/schema/validator/ObjectValidator.ts

@@ -1,7 +1,6 @@
 import { Repository } from '../../../Repository';
 import { isNullValue } from '../../../util/NullCheck';
-import { AdditionalPropertiesType } from '../object/AdditionalPropertiesType';
-import { Schema } from '../Schema';
+import { AdditionalPropertiesType, Schema } from '../Schema';
 import { SchemaValidationException } from './exception/SchemaValidationException';
 import { SchemaValidator } from './SchemaValidator';
 
@@ -100,7 +99,7 @@ export class ObjectValidator {
                     newParents,
                     apt.getSchemaValue(),
                     repository,
-                    jsonObject.get(key),
+                    jsonObject[key],
                 );
                 jsonObject[key] = element;
             }

package/src/engine/model/AbstractStatement.ts

@@ -6,6 +6,16 @@ export class AbstractStatement {
     private position?: Position;
     private override: boolean = false;
 
+    public constructor(ast?: AbstractStatement) {
+        if (!ast) return;
+        this.comment = ast.comment;
+        this.description = ast.description;
+        this.position = ast.position
+            ? new Position(ast.position.getLeft(), ast.position.getTop())
+            : undefined;
+        this.override = ast.override;
+    }
+
     public getComment(): string | undefined {
         return this.comment;
     }

package/src/engine/model/Event.ts

@@ -1,5 +1,4 @@
-import { AdditionalPropertiesType } from '../json/schema/object/AdditionalPropertiesType';
-import { Schema } from '../json/schema/Schema';
+import { AdditionalPropertiesType, Schema } from '../json/schema/Schema';
 import { SchemaType } from '../json/schema/type/SchemaType';
 import { TypeUtil } from '../json/schema/type/TypeUtil';
 import { SchemaReferenceException } from '../json/schema/validator/exception/SchemaReferenceException';
@@ -30,9 +29,17 @@ export class Event {
     private name: string;
     private parameters: Map<string, Schema>;
 
-    constructor(name: string, parameters: Map<string, Schema>) {
-        this.name = name;
-        this.parameters = parameters;
+    constructor(evn: string | Event, parameters?: Map<string, Schema>) {
+        if (evn instanceof Event) {
+            this.name = evn.name;
+            this.parameters = new Map(
+                Array.from(evn.parameters.entries()).map((e) => [e[0], new Schema(e[1])]),
+            );
+        } else {
+            this.name = evn;
+            if (!parameters) throw new Error('Unknown constructor format');
+            this.parameters = parameters;
+        }
     }
 
     public getName(): string {

package/src/engine/model/FunctionDefinition.ts

@@ -1,5 +1,4 @@
-import { AdditionalPropertiesType } from '../json/schema/object/AdditionalPropertiesType';
-import { Schema } from '../json/schema/Schema';
+import { AdditionalPropertiesType, Schema } from '../json/schema/Schema';
 import { Namespaces } from '../namespaces/Namespaces';
 import { Event } from './Event';
 import { FunctionSignature } from './FunctionSignature';

package/src/engine/model/FunctionSignature.ts

@@ -1,5 +1,4 @@
-import { AdditionalPropertiesType } from '../json/schema/object/AdditionalPropertiesType';
-import { Schema } from '../json/schema/Schema';
+import { AdditionalPropertiesType, Schema } from '../json/schema/Schema';
 import { Namespaces } from '../namespaces/Namespaces';
 import { Event } from './Event';
 import { Parameter } from './Parameter';
@@ -32,8 +31,19 @@ export class FunctionSignature {
     private parameters: Map<string, Parameter> = new Map();
     private events: Map<string, Event> = new Map();
 
-    constructor(name: string) {
-        this.name = name;
+    constructor(value: string | FunctionSignature) {
+        if (value instanceof FunctionSignature) {
+            this.name = value.name;
+            this.namespace = value.namespace;
+            this.parameters = new Map(
+                Array.from(value.parameters.entries()).map((e) => [e[0], new Parameter(e[1])]),
+            );
+            this.events = new Map(
+                Array.from(value.events.entries()).map((e) => [e[0], new Event(e[1])]),
+            );
+        } else {
+            this.name = value;
+        }
     }
 
     public getNamespace(): string {

package/src/engine/model/Parameter.ts

@@ -43,9 +43,19 @@ export class Parameter {
     private variableArgument: boolean = false;
     private type: ParameterType = ParameterType.EXPRESSION;
 
-    constructor(parameterName: string, schema: Schema) {
-        this.schema = schema;
-        this.parameterName = parameterName;
+    constructor(pn: string | Parameter, schema?: Schema) {
+        if (pn instanceof Parameter) {
+            this.schema = new Schema(pn.schema);
+            this.parameterName = pn.parameterName;
+            this.variableArgument = pn.variableArgument;
+            this.type = pn.type;
+        } else {
+            if (!schema) {
+                throw new Error('Unknown constructor signature');
+            }
+            this.schema = schema;
+            this.parameterName = pn;
+        }
     }
 
     public getSchema(): Schema {

package/src/engine/model/ParameterReference.ts

@@ -2,6 +2,7 @@ import { Schema } from '../json/schema/Schema';
 import { SchemaType } from '../json/schema/type/SchemaType';
 import { TypeUtil } from '../json/schema/type/TypeUtil';
 import { Namespaces } from '../namespaces/Namespaces';
+import { isNullValue } from '../util/NullCheck';
 import UUID from '../util/UUID';
 import { ParameterReferenceType } from './ParameterReferenceType';
 
@@ -25,9 +26,17 @@ export class ParameterReference {
     private value: any;
     private expression?: string;
 
-    constructor(type: ParameterReferenceType) {
-        this.type = type;
-        this.key = UUID();
+    constructor(type: ParameterReferenceType | ParameterReference) {
+        if (type instanceof ParameterReference) {
+            let pv = type as ParameterReference;
+            this.key = pv.key;
+            this.type = pv.type;
+            this.value = isNullValue(pv.value) ? undefined : JSON.parse(JSON.stringify(pv.value));
+            this.expression = pv.expression;
+        } else {
+            this.type = type as ParameterReferenceType;
+            this.key = UUID();
+        }
     }
 
     public getType(): ParameterReferenceType {

package/src/engine/model/Position.ts

@@ -18,7 +18,7 @@ export class Position {
     private left: number;
     private top: number;
 
-    constructor(left: number, top: number) {
+    public constructor(left: number, top: number) {
         this.left = left;
         this.top = top;
     }

package/src/engine/model/Statement.ts

@@ -1,5 +1,4 @@
-import { AdditionalPropertiesType } from '../json/schema/object/AdditionalPropertiesType';
-import { Schema } from '../json/schema/Schema';
+import { AdditionalPropertiesType, Schema } from '../json/schema/Schema';
 import { SchemaType } from '../json/schema/type/SchemaType';
 import { TypeUtil } from '../json/schema/type/TypeUtil';
 import { Namespaces } from '../namespaces/Namespaces';
@@ -49,11 +48,38 @@ export class Statement extends AbstractStatement {
     private parameterMap?: Map<string, Map<string, ParameterReference>>;
     private dependentStatements?: Map<string, boolean>;
 
-    public constructor(statementName: string, namespace: string, name: string) {
-        super();
-        this.statementName = statementName;
-        this.namespace = namespace;
-        this.name = name;
+    public constructor(sn: string | Statement, namespace?: string, name?: string) {
+        super(sn instanceof Statement ? (sn as Statement) : undefined);
+
+        if (sn instanceof Statement) {
+            let x = sn as Statement;
+            this.statementName = x.statementName;
+            this.name = x.name;
+            this.namespace = x.namespace;
+            if (x.parameterMap)
+                this.parameterMap = new Map(
+                    Array.from(x.parameterMap.entries()).map((f) => [
+                        f[0],
+                        new Map(
+                            Array.from(f[1].entries()).map((e) => [
+                                e[0],
+                                new ParameterReference(e[1]),
+                            ]),
+                        ),
+                    ]),
+                );
+
+            if (x.dependentStatements) {
+                this.dependentStatements = new Map(Array.from(x.dependentStatements.entries()));
+            }
+        } else {
+            this.statementName = sn;
+            if (!name || !namespace) {
+                throw new Error('Unknown constructor');
+            }
+            this.namespace = namespace;
+            this.name = name;
+        }
     }
 
     public getStatementName(): string {

package/src/engine/model/StatementGroup.ts

@@ -4,6 +4,7 @@ import { TypeUtil } from '../json/schema/type/TypeUtil';
 import { Namespaces } from '../namespaces/Namespaces';
 import { AbstractStatement } from './AbstractStatement';
 import { Position } from './Position';
+import { Statement } from './Statement';
 
 export class StatementGroup extends AbstractStatement {
     private static readonly SCHEMA_NAME: string = 'StatementGroup';
@@ -21,10 +22,12 @@ export class StatementGroup extends AbstractStatement {
         );
 
     private statementGroupName: string;
+    private statements: Map<string, boolean>;
 
-    constructor(statementGroupName: string) {
+    constructor(statementGroupName: string, statements: Map<string, boolean> = new Map()) {
         super();
         this.statementGroupName = statementGroupName;
+        this.statements = statements;
     }
 
     public getStatementGroupName(): string {
@@ -35,8 +38,25 @@ export class StatementGroup extends AbstractStatement {
         return this;
     }
 
+    public getStatements(): Map<string, boolean> {
+        return this.statements;
+    }
+
+    public setStatements(statements: Map<string, boolean>): StatementGroup {
+        this.statements = statements;
+        return this;
+    }
+
     public static from(json: any): StatementGroup {
-        return new StatementGroup(json.statementGroupName)
+        return new StatementGroup(
+            json.statementGroupName,
+            new Map(
+                Object.entries(json.statements || {}).map(([k, v]) => [
+                    k,
+                    ('' + v)?.toLowerCase() == 'true',
+                ]),
+            ),
+        )
             .setPosition(Position.from(json.position))
             .setComment(json.comment)
             .setDescription(json.description) as StatementGroup;

package/src/engine/runtime/KIRuntime.ts

@@ -485,7 +485,7 @@ export class KIRuntime extends AbstractFunction {
 
             let refList: ParameterReference[] = Array.from(param[1]?.values() ?? []);
 
-            if (!refList.length) {
+            if (!refList.length && !p.isVariableArgument()) {
                 if (isNullValue(SchemaUtil.getDefaultValue(p.getSchema(), sRepo)))
                     se.addMessage(
                         StatementMessageType.ERROR,
@@ -500,7 +500,7 @@ export class KIRuntime extends AbstractFunction {
 
             if (p.isVariableArgument()) {
                 for (let ref of refList) this.parameterReferenceValidation(se, p, ref, sRepo);
-            } else {
+            } else if (refList.length) {
                 let ref: ParameterReference = refList[0];
                 this.parameterReferenceValidation(se, p, ref, sRepo);
             }
@@ -515,6 +515,7 @@ export class KIRuntime extends AbstractFunction {
 
         if (paramSet.size) {
             for (let param of Array.from(paramSet.values())) {
+                if (param.isVariableArgument()) continue;
                 if (isNullValue(SchemaUtil.getDefaultValue(param.getSchema(), sRepo)))
                     se.addMessage(
                         StatementMessageType.ERROR,

package/src/engine/runtime/expression/Expression.ts

@@ -77,6 +77,33 @@ export class Expression extends ExpressionToken {
                     isPrevOp = result.getT2();
                     break;
                 }
+                case '?': {
+                    if (
+                        i + 1 < length &&
+                        this.expression.charAt(i + 1) != '?' &&
+                        i != 0 &&
+                        this.expression.charAt(i - 1) != '?'
+                    ) {
+                        i = this.processTernaryOperator(length, sb, buff, i, isPrevOp);
+                    } else {
+                        let result: Tuple2<number, boolean> = this.processOthers(
+                            chr,
+                            length,
+                            sb,
+                            buff,
+                            i,
+                            isPrevOp,
+                        );
+                        i = result.getT1();
+                        isPrevOp = result.getT2();
+                        if (isPrevOp && this.ops.peek() == Operation.ARRAY_OPERATOR) {
+                            result = this.process(length, sb, i);
+                            i = result.getT1();
+                            isPrevOp = result.getT2();
+                        }
+                    }
+                    break;
+                }
                 default:
                     let result: Tuple2<number, boolean> = this.processOthers(
                         chr,
@@ -188,6 +215,80 @@ export class Expression extends ExpressionToken {
         return new Tuple2(i, false);
     }
 
+    private processTernaryOperator(
+        length: number,
+        sb: StringBuilder,
+        buff: string,
+        i: number,
+        isPrevOp: boolean,
+    ): number {
+        if (isPrevOp) {
+            throw new ExpressionEvaluationException(
+                this.expression,
+                'Ternary operator is followed by an operator',
+            );
+        }
+
+        if (buff.trim() != '') {
+            this.tokens.push(new Expression(buff));
+            sb.setLength(0);
+        }
+
+        ++i;
+        let cnt: number = 1;
+        let inChr = '';
+        const start = i;
+        while (i < length && cnt > 0) {
+            inChr = this.expression.charAt(i);
+            if (inChr == '?') ++cnt;
+            else if (inChr == ':') --cnt;
+            ++i;
+        }
+
+        if (inChr != ':') {
+            throw new ExpressionEvaluationException(this.expression, "':' operater is missing");
+        }
+
+        if (i >= length) {
+            throw new ExpressionEvaluationException(
+                this.expression,
+                'Third part of the ternary expression is missing',
+            );
+        }
+
+        while (
+            !this.ops.isEmpty() &&
+            this.hasPrecedence(Operation.CONDITIONAL_TERNARY_OPERATOR, this.ops.peek())
+        ) {
+            let prev: Operation = this.ops.pop();
+
+            if (Operation.UNARY_OPERATORS.has(prev)) {
+                const l: ExpressionToken = this.tokens.pop();
+                this.tokens.push(new Expression('', l, undefined, prev));
+            } else {
+                let r = this.tokens.pop();
+                let l = this.tokens.pop();
+
+                this.tokens.push(new Expression('', l, r, prev));
+            }
+        }
+
+        this.ops.push(Operation.CONDITIONAL_TERNARY_OPERATOR);
+        this.tokens.push(new Expression(this.expression.substring(start, i - 1)));
+
+        const secondExp: string = this.expression.substring(i);
+        if (secondExp.trim() === '') {
+            throw new ExpressionEvaluationException(
+                this.expression,
+                'Third part of the ternary expression is missing',
+            );
+        }
+
+        this.tokens.push(new Expression(secondExp));
+
+        return length - 1;
+    }
+
     private processSubExpression(
         length: number,
         sb: StringBuilder,
@@ -329,6 +430,25 @@ export class Expression extends ExpressionToken {
                     )
                     .append(')');
                 ind++;
+            } else if (this.ops.get(i) == Operation.CONDITIONAL_TERNARY_OPERATOR) {
+                let temp: ExpressionToken = tokens[ind++];
+                sb.insert(
+                    0,
+                    temp instanceof Expression ? (temp as Expression).toString() : temp.toString(),
+                );
+                sb.insert(0, ':');
+                temp = tokens[ind++];
+                sb.insert(
+                    0,
+                    temp instanceof Expression ? (temp as Expression).toString() : temp.toString(),
+                );
+                sb.insert(0, '?');
+                temp = tokens[ind++];
+                sb.insert(
+                    0,
+                    temp instanceof Expression ? (temp as Expression).toString() : temp.toString(),
+                ).append(')');
+                sb.insert(0, '(');
             } else {
                 if (ind == 0) {
                     const temp: ExpressionToken = tokens[ind++];

package/src/engine/runtime/expression/ExpressionEvaluator.ts

@@ -40,6 +40,8 @@ import { UnaryOperator } from './operators/unary/UnaryOperator';
 import { LiteralTokenValueExtractor } from './tokenextractor/LiteralTokenValueExtractor';
 import { TokenValueExtractor } from './tokenextractor/TokenValueExtractor';
 import { Tuple2 } from '../../util/Tuples';
+import { ConditionalTernaryOperator } from './operators/ternary';
+import { TernaryOperator } from './operators/ternary/TernaryOperator';
 
 export class ExpressionEvaluator {
     private static readonly UNARY_OPERATORS_MAP: Map<Operation, UnaryOperator> = new Map([
@@ -49,6 +51,10 @@ export class ExpressionEvaluator {
         [Operation.UNARY_PLUS, new ArithmeticUnaryPlusOperator()],
     ]);
 
+    private static readonly TERNARY_OPERATORS_MAP: Map<Operation, TernaryOperator> = new Map([
+        [Operation.CONDITIONAL_TERNARY_OPERATOR, new ConditionalTernaryOperator()],
+    ]);
+
     private static readonly BINARY_OPERATORS_MAP: Map<Operation, BinaryOperator> = new Map([
         [Operation.ADDITION, new ArithmeticAdditionOperator()],
         [Operation.DIVISION, new ArithmeticDivisionOperator()],
@@ -195,6 +201,13 @@ export class ExpressionEvaluator {
                 operator == Operation.ARRAY_OPERATOR
             ) {
                 this.processObjectOrArrayOperator(valuesMap, ops, tokens, operator, token);
+            } else if (operator == Operation.CONDITIONAL_TERNARY_OPERATOR) {
+                const token2: ExpressionToken = tokens.pop();
+                const token3: ExpressionToken = tokens.pop();
+                var v1 = this.getValueFromToken(valuesMap, token3);
+                var v2 = this.getValueFromToken(valuesMap, token2);
+                var v3 = this.getValueFromToken(valuesMap, token);
+                tokens.push(this.applyTernaryOperation(operator, v1, v2, v3));
             } else {
                 const token2: ExpressionToken = tokens.pop();
                 var v1 = this.getValueFromToken(valuesMap, token2);
@@ -295,6 +308,19 @@ export class ExpressionEvaluator {
         }
     }
 
+    private applyTernaryOperation(operator: Operation, v1: any, v2: any, v3: any): ExpressionToken {
+        let op: TernaryOperator | undefined =
+            ExpressionEvaluator.TERNARY_OPERATORS_MAP.get(operator);
+
+        if (!op)
+            throw new ExpressionEvaluationException(
+                this.expression,
+                StringFormatter.format('No operator found to evaluate $', this.getExpression()),
+            );
+
+        return new ExpressionTokenValue(operator.toString(), op.apply(v1, v2, v3));
+    }
+
     private applyBinaryOperation(operator: Operation, v1: any, v2: any): ExpressionToken {
         let typv1: string = typeof v1;
         let typv2: string = typeof v2;

package/src/engine/runtime/expression/Operation.ts

@@ -34,6 +34,8 @@ export class Operation {
 
     public static readonly NULLISH_COALESCING_OPERATOR: Operation = new Operation('??');
 
+    public static readonly CONDITIONAL_TERNARY_OPERATOR: Operation = new Operation('?');
+
     private static readonly VALUE_OF: Map<string, Operation> = new Map([
         ['MULTIPLICATION', Operation.MULTIPLICATION],
         ['DIVISION', Operation.DIVISION],
@@ -64,6 +66,7 @@ export class Operation {
         ['ARRAY_OPERATOR', Operation.ARRAY_OPERATOR],
         ['OBJECT_OPERATOR', Operation.OBJECT_OPERATOR],
         ['NULLISH_COALESCING_OPERATOR', Operation.NULLISH_COALESCING_OPERATOR],
+        ['CONDITIONAL_TERNARY_OPERATOR', Operation.CONDITIONAL_TERNARY_OPERATOR],
     ]);
 
     public static readonly UNARY_OPERATORS: Set<Operation> = new Set([
@@ -109,6 +112,10 @@ export class Operation {
         Operation.BITWISE_XOR,
     ]);
 
+    public static readonly CONDITIONAL_OPERATORS: Set<Operation> = new Set([
+        Operation.CONDITIONAL_TERNARY_OPERATOR,
+    ]);
+
     public static readonly OPERATOR_PRIORITY: Map<Operation, number> = new Map([
         [Operation.UNARY_PLUS, 1],
         [Operation.UNARY_MINUS, 1],
@@ -137,6 +144,7 @@ export class Operation {
         [Operation.AND, 10],
         [Operation.OR, 11],
         [Operation.NULLISH_COALESCING_OPERATOR, 11],
+        [Operation.CONDITIONAL_TERNARY_OPERATOR, 12],
     ]);
 
     public static readonly OPERATORS: Set<string> = new Set(
@@ -146,6 +154,7 @@ export class Operation {
             ...Array.from(Operation.BITWISE_OPERATORS),
             Operation.ARRAY_OPERATOR,
             Operation.OBJECT_OPERATOR,
+            ...Array.from(Operation.CONDITIONAL_OPERATORS),
         ].map((e) => e.getOperator()),
     );
 
@@ -156,6 +165,7 @@ export class Operation {
             ...Array.from(Operation.BITWISE_OPERATORS),
             Operation.ARRAY_OPERATOR,
             Operation.OBJECT_OPERATOR,
+            ...Array.from(Operation.CONDITIONAL_OPERATORS),
         ]
             .filter((e) => !e.shouldBeWrappedInSpace())
             .map((e) => e.getOperator()),

package/src/engine/runtime/expression/operators/ternary/ConditionalTernaryOperator.ts

@@ -0,0 +1,7 @@
+import { TernaryOperator } from './TernaryOperator';
+
+export class ConditionalTernaryOperator extends TernaryOperator {
+    public apply(t: any, u: any, v: any): any {
+        return t ? u : v;
+    }
+}

package/src/engine/runtime/expression/operators/ternary/TernaryOperator.ts

@@ -0,0 +1,15 @@
+import { ExecutionException } from '../../../../exception/ExecutionException';
+import { isNullValue } from '../../../../util/NullCheck';
+import { StringFormatter } from '../../../../util/string/StringFormatter';
+import { Operation } from '../../Operation';
+
+export abstract class TernaryOperator {
+    public abstract apply(t: any, u: any, v: any): any;
+
+    public nullCheck(e1: any, e2: any, e3: any, op: Operation): void {
+        if (isNullValue(e1) || isNullValue(e2) || isNullValue(e3))
+            throw new ExecutionException(
+                StringFormatter.format('$ cannot be applied to a null value', op.getOperatorName()),
+            );
+    }
+}

package/src/engine/runtime/expression/operators/ternary/index.ts

@@ -0,0 +1 @@
+export * from './ConditionalTernaryOperator';

package/src/index.ts

@@ -53,7 +53,6 @@ export * from './engine/json/schema/type/TypeUtil';
 export * from './engine/json/schema/type/MultipleType';
 export * from './engine/json/schema/type/Type';
 export * from './engine/json/schema/type/SchemaType';
-export * from './engine/json/schema/object/AdditionalPropertiesType';
 export * from './engine/json/schema/SchemaUtil';
 export * from './engine/json/schema/string/StringFormat';
 export * from './engine/HybridRepository';
@@ -77,3 +76,4 @@ export * from './engine/exception/ExecutionException';
 export * from './engine/exception/KIRuntimeException';
 export * from './engine/runtime/expression/operators/unary';
 export * from './engine/runtime/expression/operators/binary';
+export * from './engine/runtime/expression/operators/ternary';

package/src/engine/json/schema/object/AdditionalPropertiesType.ts

@@ -1,32 +0,0 @@
-import { Schema } from '../Schema';
-
-export class AdditionalPropertiesType {
-    private booleanValue?: boolean;
-    private schemaValue?: Schema;
-
-    public getBooleanValue(): boolean | undefined {
-        return this.booleanValue;
-    }
-
-    public getSchemaValue(): Schema | undefined {
-        return this.schemaValue;
-    }
-
-    public setBooleanValue(booleanValue: boolean): AdditionalPropertiesType {
-        this.booleanValue = booleanValue;
-        return this;
-    }
-
-    public setSchemaValue(schemaValue: Schema): AdditionalPropertiesType {
-        this.schemaValue = schemaValue;
-        return this;
-    }
-
-    public static from(obj: any): AdditionalPropertiesType | undefined {
-        if (!obj) return undefined;
-        const ad = new AdditionalPropertiesType();
-        ad.booleanValue = obj.booleanValue;
-        ad.schemaValue = obj.schemaValue;
-        return ad;
-    }
-}