@fincity/kirun-js 1.0.5 → 1.1.0

package/dist/types.d.ts

@@ -1,24 +1,3 @@
-export class Tuple2<F, S> {
-    constructor(f: F, s: S);
-    getT1(): F;
-    getT2(): S;
-}
-export class Tuple3<F, S, T> extends Tuple2<F, S> {
-    constructor(f: F, s: S, t: T);
-    getT3(): T;
-}
-export class Tuple4<F, S, T, FR> extends Tuple3<F, S, T> {
-    constructor(f: F, s: S, t: T, fr: FR);
-    getT4(): FR;
-}
-export interface Repository<T> {
-    find(namespace: string, name: string): T | undefined;
-}
-export class HybridRepository<T> implements Repository<T> {
-    repos: Repository<T>[];
-    constructor(...repos: Repository<T>[]);
-    find(namespace: string, name: string): T | undefined;
-}
 export class Namespaces {
     static readonly SYSTEM: string;
     static readonly SYSTEM_CTX: string;
@@ -29,7 +8,7 @@ export class Namespaces {
     private constructor();
 }
 export function isNullValue(v: any): boolean;
-declare class ArraySchemaType {
+export class ArraySchemaType {
     setSingleSchema(schema: Schema): ArraySchemaType;
     setTupleSchema(schemas: Schema[]): ArraySchemaType;
     getSingleSchema(): Schema | undefined;
@@ -38,14 +17,14 @@ declare class ArraySchemaType {
     static of(...schemas: Schema[]): ArraySchemaType;
     static from(obj: any): ArraySchemaType | undefined;
 }
-declare class AdditionalPropertiesType {
+export class AdditionalPropertiesType {
     getBooleanValue(): boolean | undefined;
     getSchemaValue(): Schema | undefined;
     setBooleanValue(booleanValue: boolean): AdditionalPropertiesType;
     setSchemaValue(schemaValue: Schema): AdditionalPropertiesType;
     static from(obj: any): AdditionalPropertiesType | undefined;
 }
-enum StringFormat {
+export enum StringFormat {
     DATETIME = "DATETIME",
     TIME = "TIME",
     DATE = "DATE",
@@ -63,10 +42,27 @@ export enum SchemaType {
     BOOLEAN = "Boolean",
     NULL = "Null"
 }
-declare abstract class Type {
+export abstract class Type {
     abstract getAllowedSchemaTypes(): Set<SchemaType>;
     abstract contains(type: SchemaType): boolean;
 }
+export class MultipleType extends Type {
+    constructor(type: Set<SchemaType>);
+    getType(): Set<SchemaType>;
+    setType(type: Set<SchemaType>): MultipleType;
+    getAllowedSchemaTypes(): Set<SchemaType>;
+    contains(type: SchemaType): boolean;
+}
+export class SingleType extends Type {
+    constructor(type: SchemaType);
+    getType(): SchemaType;
+    getAllowedSchemaTypes(): Set<SchemaType>;
+    contains(type: SchemaType): boolean;
+}
+export class TypeUtil {
+    static of(...types: SchemaType[]): Type;
+    static from(types: any): Type | undefined;
+}
 export class Schema {
     static readonly NULL: Schema;
     static readonly SCHEMA: Schema;
@@ -164,39 +160,32 @@ export class Schema {
     getPermission(): string | undefined;
     setPermission(permission: string): Schema;
 }
-export class KIRuntimeException extends Error {
-    constructor(message: string, err?: Error);
-    getCause(): Error | undefined;
-}
-export class StringFormatter {
-    static format(formatString: string, ...params: any[]): string;
-    private constructor();
-}
-export class StringUtil {
-    private constructor();
-    static nthIndex(str: string, c: string, from: number | undefined, occurance: number): number;
-    static splitAtFirstOccurance(str: string, c: string): [string | undefined, string | undefined];
-    static isNullOrBlank(str: string | undefined): boolean;
+export enum ParameterType {
+    CONSTANT = "CONSTANT",
+    EXPRESSION = "EXPRESSION"
 }
-export class SchemaValidator {
-    static path(parents: Schema[] | undefined): string;
-    static validate(parents: Schema[] | undefined, schema: Schema | undefined, repository: Repository<Schema> | undefined, element: any): any;
-    static constantValidation(parents: Schema[], schema: Schema, element: any): any;
-    static enumCheck(parents: Schema[], schema: Schema, element: any): any;
-    static typeValidation(parents: Schema[], schema: Schema, repository: Repository<Schema> | undefined, element: any): void;
-    private constructor();
+export class Parameter {
+    static readonly SCHEMA: Schema;
+    static readonly EXPRESSION: Schema;
+    constructor(parameterName: string, schema: Schema);
+    getSchema(): Schema;
+    setSchema(schema: Schema): Parameter;
+    getParameterName(): string;
+    setParameterName(parameterName: string): Parameter;
+    isVariableArgument(): boolean;
+    setVariableArgument(variableArgument: boolean): Parameter;
+    getType(): ParameterType;
+    setType(type: ParameterType): Parameter;
+    static ofEntry(name: string, schema: Schema, variableArgument?: boolean, type?: ParameterType): [string, Parameter];
+    static of(name: string, schema: Schema, variableArgument?: boolean, type?: ParameterType): Parameter;
 }
-export class KIRunConstants {
-    static readonly NAMESPACE: String;
-    static readonly NAME: String;
-    static readonly ID: String;
-    private constructor();
+export interface Repository<T> {
+    find(namespace: string, name: string): T | undefined;
 }
-export class ExecutionException extends Error {
-    constructor(message: string, err?: Error);
-    getCause(): Error | undefined;
+export class KIRunSchemaRepository implements Repository<Schema> {
+    find(namespace: string, name: string): Schema | undefined;
 }
-declare class Event {
+export class Event {
     static readonly OUTPUT: string;
     static readonly ERROR: string;
     static readonly ITERATION: string;
@@ -212,7 +201,11 @@ declare class Event {
     static outputEventMapEntry(parameters: Map<string, Schema>): [string, Event];
     static eventMapEntry(eventName: string, parameters: Map<string, Schema>): [string, Event];
 }
-declare class EventResult {
+export class KIRuntimeException extends Error {
+    constructor(message: string, err?: Error);
+    getCause(): Error | undefined;
+}
+export class EventResult {
     constructor(name: string, result: Map<string, any>);
     getName(): string;
     setName(name: string): EventResult;
@@ -221,34 +214,15 @@ declare class EventResult {
     static outputOf(result: Map<string, any>): EventResult;
     static of(eventName: string, result: Map<string, any>): EventResult;
 }
-interface FunctionOutputGenerator {
+export interface FunctionOutputGenerator {
     next(): EventResult | undefined;
 }
-declare class FunctionOutput {
+export class FunctionOutput {
     constructor(arg: EventResult[] | FunctionOutputGenerator);
     next(): EventResult | undefined;
     allResults(): EventResult[];
 }
-enum ParameterType {
-    CONSTANT = "CONSTANT",
-    EXPRESSION = "EXPRESSION"
-}
-declare class Parameter {
-    static readonly SCHEMA: Schema;
-    static readonly EXPRESSION: Schema;
-    constructor(parameterName: string, schema: Schema);
-    getSchema(): Schema;
-    setSchema(schema: Schema): Parameter;
-    getParameterName(): string;
-    setParameterName(parameterName: string): Parameter;
-    isVariableArgument(): boolean;
-    setVariableArgument(variableArgument: boolean): Parameter;
-    getType(): ParameterType;
-    setType(type: ParameterType): Parameter;
-    static ofEntry(name: string, schema: Schema, variableArgument?: boolean, type?: ParameterType): [string, Parameter];
-    static of(name: string, schema: Schema, variableArgument?: boolean, type?: ParameterType): Parameter;
-}
-declare class FunctionSignature {
+export class FunctionSignature {
     static readonly SCHEMA: Schema;
     constructor(name: string);
     getNamespace(): string;
@@ -260,7 +234,7 @@ declare class FunctionSignature {
     getEvents(): Map<string, Event>;
     setEvents(events: Map<string, Event>): FunctionSignature;
 }
-declare class ContextElement {
+export class ContextElement {
     static readonly NULL: ContextElement;
     constructor(schema?: Schema, element?: any);
     getSchema(): Schema | undefined;
@@ -268,6 +242,16 @@ declare class ContextElement {
     getElement(): any;
     setElement(element: any): ContextElement;
 }
+export class StringFormatter {
+    static format(formatString: string, ...params: any[]): string;
+    private constructor();
+}
+export class StringUtil {
+    private constructor();
+    static nthIndex(str: string, c: string, from: number | undefined, occurance: number): number;
+    static splitAtFirstOccurance(str: string, c: string): [string | undefined, string | undefined];
+    static isNullOrBlank(str: string | undefined): boolean;
+}
 export class ExpressionEvaluationException extends Error {
     constructor(expression: string, message: string, err?: Error);
     getCause(): Error | undefined;
@@ -280,7 +264,7 @@ export abstract class TokenValueExtractor {
     protected abstract getValueInternal(token: string): any;
     abstract getPrefix(): string;
 }
-declare class Position {
+export class Position {
     static readonly SCHEMA_NAME: string;
     static readonly SCHEMA: Schema;
     constructor(left: number, top: number);
@@ -289,7 +273,7 @@ declare class Position {
     getTop(): number;
     setTop(top: number): Position;
 }
-declare class AbstractStatement {
+export class AbstractStatement {
     getComment(): string | undefined;
     setComment(comment: string): AbstractStatement;
     getDescription(): string | undefined;
@@ -297,11 +281,11 @@ declare class AbstractStatement {
     getPosition(): Position | undefined;
     setPosition(position: Position): AbstractStatement;
 }
-enum ParameterReferenceType {
+export enum ParameterReferenceType {
     VALUE = "VALUE",
     EXPRESSION = "EXPRESSION"
 }
-declare class ParameterReference {
+export class ParameterReference {
     static readonly SCHEMA: Schema;
     constructor(type: ParameterReferenceType);
     getType(): ParameterReferenceType;
@@ -313,7 +297,7 @@ declare class ParameterReference {
     static ofExpression(value: any): ParameterReference;
     static ofValue(value: any): ParameterReference;
 }
-declare class Statement extends AbstractStatement {
+export class Statement extends AbstractStatement {
     static readonly SCHEMA_NAME: string;
     static readonly SCHEMA: Schema;
     constructor(statementName: string, namespace: string, name: string);
@@ -330,16 +314,16 @@ declare class Statement extends AbstractStatement {
     equals(obj: any): boolean;
     static ofEntry(statement: Statement): [string, Statement];
 }
-interface GraphVertexType<K> {
+export interface GraphVertexType<K> {
     getUniqueKey(): K;
     getDepenedencies(): Set<string>;
 }
-enum StatementMessageType {
+export enum StatementMessageType {
     ERROR = "ERROR",
     WARNING = "WARNING",
     MESSAGE = "MESSAGE"
 }
-declare class StatementMessage {
+export class StatementMessage {
     constructor(messageType?: StatementMessageType, message?: string);
     getMessageType(): StatementMessageType | undefined;
     setMessageType(messageType: StatementMessageType): StatementMessage;
@@ -347,7 +331,7 @@ declare class StatementMessage {
     setMessage(message: string): StatementMessage;
     toString(): string;
 }
-declare class StatementExecution implements GraphVertexType<String> {
+export class StatementExecution implements GraphVertexType<String> {
     constructor(statement: Statement);
     getStatement(): Statement;
     setStatement(statement: Statement): StatementExecution;
@@ -361,7 +345,25 @@ declare class StatementExecution implements GraphVertexType<String> {
     getDepenedencies(): Set<string>;
     equals(obj: Object): boolean;
 }
-declare class FunctionExecutionParameters {
+export class ArgumentsTokenValueExtractor extends TokenValueExtractor {
+    static readonly PREFIX: string;
+    constructor(args: Map<string, any>);
+    protected getValueInternal(token: string): any;
+    getPrefix(): string;
+}
+export class ContextTokenValueExtractor extends TokenValueExtractor {
+    static readonly PREFIX: string;
+    constructor(context: Map<string, ContextElement>);
+    protected getValueInternal(token: string): any;
+    getPrefix(): string;
+}
+export class OutputMapTokenValueExtractor extends TokenValueExtractor {
+    static readonly PREFIX: string;
+    constructor(output: Map<string, Map<string, Map<string, any>>>);
+    protected getValueInternal(token: string): any;
+    getPrefix(): string;
+}
+export class FunctionExecutionParameters {
     getContext(): Map<string, ContextElement> | undefined;
     setContext(context: Map<string, ContextElement>): FunctionExecutionParameters;
     getArguments(): Map<string, any> | undefined;
@@ -379,30 +381,90 @@ declare class FunctionExecutionParameters {
 export interface Function {
     getSignature(): FunctionSignature;
     getProbableEventSignature(probableParameters: Map<string, Schema[]>): Map<string, Event>;
-    execute(context: FunctionExecutionParameters): FunctionOutput;
+    execute(context: FunctionExecutionParameters): Promise<FunctionOutput>;
+}
+export class Tuple2<F, S> {
+    constructor(f: F, s: S);
+    getT1(): F;
+    getT2(): S;
+}
+export class Tuple3<F, S, T> extends Tuple2<F, S> {
+    constructor(f: F, s: S, t: T);
+    getT3(): T;
+}
+export class Tuple4<F, S, T, FR> extends Tuple3<F, S, T> {
+    constructor(f: F, s: S, t: T, fr: FR);
+    getT4(): FR;
+}
+export class SchemaReferenceException extends Error {
+    constructor(schemaPath: string, message: string, err?: Error);
+    getSchemaPath(): string;
+    getCause(): Error | undefined;
+}
+export class SchemaValidationException extends Error {
+    constructor(schemaPath: string, message: string, sve?: SchemaValidationException[], err?: Error);
+    getSchemaPath(): string;
+    getCause(): Error | undefined;
+}
+export class SchemaUtil {
+    static getDefaultValue(s: Schema | undefined, sRepository: Repository<Schema>): any;
+    static getSchemaFromRef(schema: Schema, sRepository: Repository<Schema> | undefined, ref: string | undefined, iteration?: number): Schema | undefined;
+    private constructor();
+}
+export class AnyOfAllOfOneOfValidator {
+    static validate(parents: Schema[], schema: Schema, repository: Repository<Schema> | undefined, element: any): any;
+    private constructor();
+}
+export class ArrayValidator {
+    static validate(parents: Schema[], schema: Schema, repository: Repository<Schema> | undefined, element: any): any;
+    static checkContains(parents: Schema[], schema: Schema, repository: Repository<Schema> | undefined, array: any[]): void;
+    static checkUniqueItems(parents: Schema[], schema: Schema, array: any[]): void;
+    static checkMinMaxItems(parents: Schema[], schema: Schema, array: any[]): void;
+    static checkItems(parents: Schema[], schema: Schema, repository: Repository<Schema> | undefined, array: any[]): void;
+    private constructor();
+}
+export class BooleanValidator {
+    static validate(parents: Schema[], schema: Schema, element: any): any;
+    private constructor();
+}
+export class NullValidator {
+    static validate(parents: Schema[], schema: Schema, element: any): any;
+    private constructor();
+}
+export class NumberValidator {
+    static validate(type: SchemaType, parents: Schema[], schema: Schema, element: any): any;
+    private constructor();
+}
+export class ObjectValidator {
+    static validate(parents: Schema[], schema: Schema, repository: Repository<Schema> | undefined, element: any): void;
+    private constructor();
+}
+export class StringValidator {
+    static validate(parents: Schema[], schema: Schema, element: any): any;
+    private constructor();
+}
+export class TypeValidator {
+    static validate(parents: Schema[], type: SchemaType, schema: Schema, repository: Repository<Schema> | undefined, element: any): any;
+    private constructor();
+}
+export class SchemaValidator {
+    static path(parents: Schema[] | undefined): string;
+    static validate(parents: Schema[] | undefined, schema: Schema | undefined, repository: Repository<Schema> | undefined, element: any): any;
+    static constantValidation(parents: Schema[], schema: Schema, element: any): any;
+    static enumCheck(parents: Schema[], schema: Schema, element: any): any;
+    static typeValidation(parents: Schema[], schema: Schema, repository: Repository<Schema> | undefined, element: any): void;
+    private constructor();
 }
 export abstract class AbstractFunction implements Function {
     protected validateArguments(args: Map<string, any>): Map<string, any>;
-    execute(context: FunctionExecutionParameters): FunctionOutput;
+    execute(context: FunctionExecutionParameters): Promise<FunctionOutput>;
     getProbableEventSignature(probableParameters: Map<string, Schema[]>): Map<string, Event>;
-    protected abstract internalExecute(context: FunctionExecutionParameters): FunctionOutput;
+    protected abstract internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput>;
     abstract getSignature(): FunctionSignature;
 }
-declare class StatementGroup extends AbstractStatement {
-    static readonly SCHEMA: Schema;
-    constructor(statementGroupName: string);
-    getStatementGroupName(): string;
-    setStatementGroupName(statementGroupName: string): StatementGroup;
-}
-declare class FunctionDefinition extends FunctionSignature {
-    static readonly SCHEMA: Schema;
-    constructor(name: string);
-    getVersion(): number;
-    setVersion(version: number): FunctionDefinition;
-    getSteps(): Map<string, Statement>;
-    setSteps(steps: Map<string, Statement>): FunctionDefinition;
-    getStepGroups(): Map<string, StatementGroup> | undefined;
-    setStepGroups(stepGroups: Map<string, StatementGroup>): FunctionDefinition;
+export class ExecutionException extends Error {
+    constructor(message: string, err?: Error);
+    getCause(): Error | undefined;
 }
 export class LinkedList<T> {
     length: number;
@@ -425,6 +487,24 @@ export class LinkedList<T> {
     map<U>(callbackfn: (value: T, index: number) => U, thisArg?: any): LinkedList<U>;
     forEach(callbackfn: (value: T, index: number) => void, thisArg?: any): void;
 }
+export class KIRunConstants {
+    static readonly NAMESPACE: String;
+    static readonly NAME: String;
+    static readonly ID: String;
+    private constructor();
+}
+export class StringBuilder {
+    constructor(str?: string);
+    append(x: any): StringBuilder;
+    toString(): string;
+    trim(): StringBuilder;
+    setLength(num: number): StringBuilder;
+    length(): number;
+    charAt(index: number): string;
+    deleteCharAt(index: number): StringBuilder;
+    insert(index: number, str: string): StringBuilder;
+    substring(start: number, end: number): string;
+}
 export class ExpressionToken {
     expression: string;
     constructor(expression: string);
@@ -533,6 +613,19 @@ export class BitwiseUnsignedRightShiftOperator extends BinaryOperator {
 export class BitwiseXorOperator extends BinaryOperator {
     apply(t: any, u: any): any;
 }
+export class JsonExpression {
+    constructor(expression: string);
+    getExpression(): string;
+}
+export class PrimitiveUtil {
+    static findPrimitiveNullAsBoolean(element: any): Tuple2<SchemaType, any>;
+    static findPrimitive(element: any): Tuple2<SchemaType, any>;
+    static findPrimitiveNumberType(element: any): Tuple2<SchemaType, any>;
+    static compare(a: any, b: any): number;
+    static comparePrimitive(oa: any, ob: any): number;
+    static toPrimitiveType(e: any): number;
+    private constructor();
+}
 export class LogicalAndOperator extends BinaryOperator {
     apply(t: any, u: any): any;
 }
@@ -576,13 +669,34 @@ export class BitwiseComplementOperator extends UnaryOperator {
 export class LogicalNotOperator extends UnaryOperator {
     apply(t: any): any;
 }
+export class LiteralTokenValueExtractor extends TokenValueExtractor {
+    static readonly INSTANCE: LiteralTokenValueExtractor;
+    protected getValueInternal(token: string): any;
+    getPrefix(): string;
+}
 export class ExpressionEvaluator {
     constructor(exp: Expression | string);
     evaluate(valuesMap: Map<string, TokenValueExtractor>): any;
     getExpression(): Expression;
     getExpressionString(): string;
 }
-declare class GraphVertex<K, T extends GraphVertexType<K>> {
+export class StatementGroup extends AbstractStatement {
+    static readonly SCHEMA: Schema;
+    constructor(statementGroupName: string);
+    getStatementGroupName(): string;
+    setStatementGroupName(statementGroupName: string): StatementGroup;
+}
+export class FunctionDefinition extends FunctionSignature {
+    static readonly SCHEMA: Schema;
+    constructor(name: string);
+    getVersion(): number;
+    setVersion(version: number): FunctionDefinition;
+    getSteps(): Map<string, Statement>;
+    setSteps(steps: Map<string, Statement>): FunctionDefinition;
+    getStepGroups(): Map<string, StatementGroup> | undefined;
+    setStepGroups(stepGroups: Map<string, StatementGroup>): FunctionDefinition;
+}
+export class GraphVertex<K, T extends GraphVertexType<K>> {
     constructor(graph: ExecutionGraph<K, T>, data: T);
     getData(): T;
     setData(data: T): GraphVertex<K, T>;
@@ -600,7 +714,7 @@ declare class GraphVertex<K, T extends GraphVertexType<K>> {
     getSubGraphOfType(type: string): ExecutionGraph<K, T>;
     toString(): string;
 }
-declare class ExecutionGraph<K, T extends GraphVertexType<K>> {
+export class ExecutionGraph<K, T extends GraphVertexType<K>> {
     constructor(isSubGrph?: boolean);
     getVerticesData(): T[];
     addVertex(data: T): GraphVertex<K, T>;
@@ -616,8 +730,43 @@ declare class ExecutionGraph<K, T extends GraphVertexType<K>> {
 export class KIRuntime extends AbstractFunction {
     constructor(fd: FunctionDefinition, functionRepository: Repository<Function>, schemaRepository: Repository<Schema>);
     getSignature(): FunctionSignature;
-    protected internalExecute(inContext: FunctionExecutionParameters): FunctionOutput;
+    protected internalExecute(inContext: FunctionExecutionParameters): Promise<FunctionOutput>;
     makeEdges(graph: ExecutionGraph<string, StatementExecution>): Tuple2<string, string>[];
 }
+export class MapUtil {
+    static of<K, V>(k1?: K, v1?: V, k2?: K, v2?: V, k3?: K, v3?: V, k4?: K, v4?: V, k5?: K, v5?: V, k6?: K, v6?: V, k7?: K, v7?: V, k8?: K, v8?: V, k9?: K, v9?: V, k10?: K, v10?: V): Map<K, V>;
+    static ofArrayEntries<K, V>(...entry: [K, V][]): Map<K, V>;
+    static entry<K, V>(k: K, v: V): MapEntry<K, V>;
+    static ofEntries<K, V>(...entry: MapEntry<K, V>[]): Map<K, V>;
+    private constructor();
+}
+export class MapEntry<K, V> {
+    k: K;
+    v: V;
+    constructor(k: K, v: V);
+}
+export class HybridRepository<T> implements Repository<T> {
+    repos: Repository<T>[];
+    constructor(...repos: Repository<T>[]);
+    find(namespace: string, name: string): T | undefined;
+}
+export class KIRunFunctionRepository extends HybridRepository<Function> {
+    constructor();
+}
+export class ArrayUtil {
+    static removeAListFrom(source: any[], removeList: any[]): void;
+    static of<K>(...k: K[]): K[];
+    private constructor();
+}
+export class Argument {
+    constructor(argumentIndex: number, name: string, value?: any);
+    getArgumentIndex(): number;
+    setArgumentIndex(argumentIndex: number): Argument;
+    getName(): string;
+    setName(name: string): Argument;
+    getValue(): any;
+    setValue(value: any): Argument;
+    static of(name: string, value: any): Argument;
+}
 
 //# sourceMappingURL=types.d.ts.map