@fincity/kirun-js 2.7.0 → 2.8.3

package/src/engine/function/system/date/GetNames.ts

@@ -0,0 +1,74 @@
+import { Parameter } from '../../../model/Parameter';
+import { AbstractDateFunction } from './AbstractDateFunction';
+import { Event } from '../../../model/Event';
+import { Schema } from '../../../json/schema/Schema';
+import { MapUtil } from '../../../util/MapUtil';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { DateTime } from 'luxon';
+import { EventResult } from '../../../model/EventResult';
+
+export class GetNames extends AbstractDateFunction {
+    public static readonly EVENT_NAMES_NAME = 'names';
+    public static readonly PARAMETER_UNIT_NAME = 'unit';
+    public static readonly PARAMETER_LOCALE_NAME = 'locale';
+
+    constructor() {
+        super(
+            'GetNames',
+            new Event(
+                GetNames.EVENT_NAMES_NAME,
+                MapUtil.of(
+                    GetNames.EVENT_NAMES_NAME,
+                    Schema.ofArray(
+                        GetNames.EVENT_NAMES_NAME,
+                        Schema.ofString(GetNames.EVENT_NAMES_NAME),
+                    ),
+                ),
+            ),
+            new Parameter(
+                GetNames.PARAMETER_UNIT_NAME,
+                Schema.ofString(GetNames.PARAMETER_UNIT_NAME).setEnums([
+                    'TIMEZONES',
+                    'MONTHS',
+                    'WEEKDAYS',
+                ]),
+            ),
+            new Parameter(
+                GetNames.PARAMETER_LOCALE_NAME,
+                Schema.ofString(GetNames.PARAMETER_LOCALE_NAME).setDefaultValue('system'),
+            ),
+        );
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        const unit = context.getArguments()?.get(GetNames.PARAMETER_UNIT_NAME);
+        const locale = context.getArguments()?.get(GetNames.PARAMETER_LOCALE_NAME);
+
+        return new FunctionOutput([
+            EventResult.outputOf(
+                MapUtil.of(GetNames.EVENT_NAMES_NAME, this.getNames(unit, locale)),
+            ),
+        ]);
+    }
+
+    private getNames(unit: string, locale: string): string[] {
+        if (unit === 'TIMEZONES') {
+            return Intl.supportedValuesOf('timeZone');
+        }
+
+        if (unit === 'MONTHS') {
+            return [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12].map((month) =>
+                DateTime.now().setLocale(locale).set({ month }).toFormat('MMMM'),
+            );
+        }
+
+        if (unit === 'WEEKDAYS') {
+            return [1, 2, 3, 4, 5, 6, 7].map((day) =>
+                DateTime.now().setLocale(locale).set({ month: 7, day }).toFormat('EEEE'),
+            );
+        }
+
+        return [];
+    }
+}

package/src/engine/function/system/date/IsBetween.ts

@@ -0,0 +1,62 @@
+import { Schema } from '../../../json/schema/Schema';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { Parameter } from '../../../model/Parameter';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { AbstractDateFunction } from './AbstractDateFunction';
+import { getDateTime } from './common';
+
+export class IsBetween extends AbstractDateFunction {
+    public static readonly PARAMETER_START_TIMESTAMP_NAME = 'startTimestamp';
+    public static readonly PARAMETER_END_TIMESTAMP_NAME = 'endTimestamp';
+
+    public static readonly PARAMETER_CHECK_TIMESTAMP_NAME = 'checkTimestamp';
+
+    constructor() {
+        super(
+            'IsBetween',
+            IsBetween.EVENT_BOOLEAN,
+            Parameter.of(
+                IsBetween.PARAMETER_START_TIMESTAMP_NAME,
+                Schema.ofRef(Namespaces.DATE + '.Timestamp'),
+            ),
+            Parameter.of(
+                IsBetween.PARAMETER_END_TIMESTAMP_NAME,
+                Schema.ofRef(Namespaces.DATE + '.Timestamp'),
+            ),
+            Parameter.of(
+                IsBetween.PARAMETER_CHECK_TIMESTAMP_NAME,
+                Schema.ofRef(Namespaces.DATE + '.Timestamp'),
+            ),
+        );
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        const startTimestamp = context
+            .getArguments()
+            ?.get(IsBetween.PARAMETER_START_TIMESTAMP_NAME);
+        const endTimestamp = context.getArguments()?.get(IsBetween.PARAMETER_END_TIMESTAMP_NAME);
+        const checkTimestamp = context
+            .getArguments()
+            ?.get(IsBetween.PARAMETER_CHECK_TIMESTAMP_NAME);
+
+        let startDateTime = getDateTime(startTimestamp);
+        let endDateTime = getDateTime(endTimestamp);
+        const checkDateTime = getDateTime(checkTimestamp);
+
+        if (startDateTime > endDateTime) {
+            [startDateTime, endDateTime] = [endDateTime, startDateTime];
+        }
+
+        return new FunctionOutput([
+            EventResult.outputOf(
+                MapUtil.of(
+                    IsBetween.EVENT_RESULT_NAME,
+                    startDateTime <= checkDateTime && checkDateTime <= endDateTime,
+                ),
+            ),
+        ]);
+    }
+}

package/src/engine/function/system/date/IsValidISODate.ts

@@ -1,43 +1,57 @@
-import { KIRuntimeException } from "../../../exception/KIRuntimeException";
-import { Schema } from "../../../json/schema/Schema";
+import { Schema } from '../../../json/schema/Schema';
 import { Event } from '../../../model/Event';
-import { EventResult } from "../../../model/EventResult";
-import { FunctionOutput } from "../../../model/FunctionOutput";
-import { FunctionSignature } from "../../../model/FunctionSignature";
-import { Parameter } from "../../../model/Parameter";
-import { Namespaces } from "../../../namespaces/Namespaces";
-import { FunctionExecutionParameters } from "../../../runtime/FunctionExecutionParameters";
-import { MapUtil } from "../../../util/MapUtil";
-import { isNullValue } from "../../../util/NullCheck";
-import { ValidDateTimeUtil } from "../../../util/ValidDateTimeUtil";
-import { AbstractFunction } from "../../AbstractFunction";
-
-
-const VALUE : string = "isoDate";
-
-const OUTPUT : string = "output";
-
-const SIGNATURE = new FunctionSignature('IsValidISODate')
-.setNamespace(Namespaces.DATE)
-.setParameters(MapUtil.of(VALUE, Parameter.of(VALUE, Schema.ofRef(Namespaces.DATE + ".timeStamp"))))
-.setEvents(MapUtil.of(OUTPUT , new Event(OUTPUT , MapUtil.of(OUTPUT, Schema.ofBoolean(OUTPUT)))));
-
-export class IsValidISODate extends AbstractFunction{
-
-    public getSignature(): FunctionSignature {
-        return SIGNATURE;
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionSignature } from '../../../model/FunctionSignature';
+import { Parameter } from '../../../model/Parameter';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { AbstractFunction } from '../../AbstractFunction';
+import { AbstractDateFunction } from './AbstractDateFunction';
+import { DateTime } from 'luxon';
+
+export class IsValidISODate extends AbstractFunction {
+    private static readonly SIGNATURE = new FunctionSignature('IsValidISODate')
+        .setNamespace(Namespaces.DATE)
+        .setParameters(
+            new Map([
+                Parameter.ofEntry(
+                    AbstractDateFunction.PARAMETER_TIMESTAMP_NAME,
+                    Schema.ofString(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME),
+                ),
+            ]),
+        )
+        .setEvents(
+            new Map([
+                Event.outputEventMapEntry(
+                    MapUtil.of(
+                        AbstractDateFunction.EVENT_RESULT_NAME,
+                        Schema.ofBoolean(AbstractDateFunction.EVENT_RESULT_NAME),
+                    ),
+                ),
+            ]),
+        );
+
+    protected internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        const timestamp = context
+            .getArguments()
+            ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME);
+
+        const dt = DateTime.fromISO(timestamp);
+
+        return Promise.resolve(
+            new FunctionOutput([
+                EventResult.outputOf(
+                    MapUtil.of(
+                        AbstractDateFunction.EVENT_RESULT_NAME,
+                        dt.isValid,
+                    ),
+                ),
+            ]),
+        );
     }
-
-    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
-        
-        var date = context.getArguments()?.get(VALUE);
-
-        if(isNullValue(date))
-            throw new KIRuntimeException("Please provide a valid date object");
-
-        return new FunctionOutput([ EventResult.of(OUTPUT , MapUtil.of( OUTPUT , ValidDateTimeUtil.validate(date)))]);
-        
+    public getSignature(): FunctionSignature {
+        return IsValidISODate.SIGNATURE;
     }
-    
-
-}
+}

package/src/engine/function/system/date/LastFirstOf.ts

@@ -0,0 +1,72 @@
+import { DateTime } from 'luxon';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionSignature } from '../../../model/FunctionSignature';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { AbstractFunction } from '../../AbstractFunction';
+import { AbstractDateFunction } from './AbstractDateFunction';
+import { Parameter } from '../../../model/Parameter';
+import { Schema } from '../../../json/schema/Schema';
+import { getDateTime } from './common';
+
+export class LastFirstOf extends AbstractFunction {
+    private readonly signature: FunctionSignature;
+    private readonly isLast: boolean;
+
+    constructor(isLast: boolean) {
+        super();
+
+        this.isLast = isLast;
+        this.signature = new FunctionSignature(isLast ? 'LastOf' : 'FirstOf')
+            .setNamespace(Namespaces.DATE)
+            .setParameters(
+                new Map([
+                    [
+                        AbstractDateFunction.PARAMETER_TIMESTAMP_NAME,
+                        new Parameter(
+                            AbstractDateFunction.PARAMETER_TIMESTAMP_NAME,
+                            Schema.ofRef(Namespaces.DATE + '.Timestamp'),
+                        ).setVariableArgument(true),
+                    ],
+                ]),
+            )
+            .setEvents(
+                new Map([
+                    [
+                        AbstractDateFunction.EVENT_TIMESTAMP_NAME,
+                        AbstractDateFunction.EVENT_TIMESTAMP,
+                    ],
+                ]),
+            );
+    }
+
+    public getSignature(): FunctionSignature {
+        return this.signature;
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        const timestamps = context
+            .getArguments()
+            ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME);
+
+        if (!timestamps?.length) {
+            throw new Error('No timestamps provided');
+        }
+
+        const dateTimes: DateTime[] = timestamps.map((ts: string) => getDateTime(ts));
+        dateTimes.sort((a, b) => a.toMillis() - b.toMillis());
+
+        return Promise.resolve(
+            new FunctionOutput([
+                EventResult.outputOf(
+                    MapUtil.of(
+                        AbstractDateFunction.EVENT_TIMESTAMP_NAME,
+                        dateTimes[this.isLast ? dateTimes.length - 1 : 0].toISO(),
+                    ),
+                ),
+            ]),
+        );
+    }
+}

package/src/engine/function/system/date/SetTimeZone.ts

@@ -0,0 +1,43 @@
+import { Schema } from '../../../json/schema/Schema';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { Parameter } from '../../../model/Parameter';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { AbstractDateFunction } from './AbstractDateFunction';
+import { getDateTime } from './common';
+
+export class SetTimeZone extends AbstractDateFunction {
+    public static readonly PARAMETER_TIMEZONE_NAME: string = 'timezone';
+
+    constructor() {
+        super(
+            'SetTimeZone',
+            AbstractDateFunction.EVENT_TIMESTAMP,
+            AbstractDateFunction.PARAMETER_TIMESTAMP,
+            Parameter.of(
+                SetTimeZone.PARAMETER_TIMEZONE_NAME,
+                Schema.ofString(SetTimeZone.PARAMETER_TIMEZONE_NAME),
+            ),
+        );
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        const timestamp = context
+            .getArguments()
+            ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME);
+
+        const dateTime = getDateTime(timestamp);
+
+        const timeZone = context.getArguments()?.get(SetTimeZone.PARAMETER_TIMEZONE_NAME);
+
+        return new FunctionOutput([
+            EventResult.outputOf(
+                MapUtil.of(
+                    AbstractDateFunction.EVENT_RESULT_NAME,
+                    dateTime.setZone(timeZone).toISO()!,
+                ),
+            ),
+        ]);
+    }
+}

package/src/engine/function/system/date/StartEndOf.ts

@@ -0,0 +1,44 @@
+import { DurationLikeObject } from 'luxon';
+import { Schema } from '../../../json/schema/Schema';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { Parameter } from '../../../model/Parameter';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { AbstractDateFunction } from './AbstractDateFunction';
+import { getDateTime } from './common';
+
+export class StartEndOf extends AbstractDateFunction {
+    private readonly isStart: boolean;
+
+    constructor(isStart: boolean) {
+        super(
+            isStart ? 'StartOf' : 'EndOf',
+            AbstractDateFunction.EVENT_TIMESTAMP,
+            AbstractDateFunction.PARAMETER_TIMESTAMP,
+            AbstractDateFunction.PARAMETER_UNIT,
+        );
+
+        this.isStart = isStart;
+    }
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        const timestamp = context
+            .getArguments()
+            ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME);
+
+        const dateTime = getDateTime(timestamp);
+
+        const unit = context
+            .getArguments()
+            ?.get(AbstractDateFunction.PARAMETER_UNIT_NAME)
+            ?.toLowerCase();
+
+        const newDateTime = this.isStart ? dateTime.startOf(unit) : dateTime.endOf(unit);
+
+        return new FunctionOutput([
+            EventResult.outputOf(
+                MapUtil.of(AbstractDateFunction.EVENT_TIMESTAMP_NAME, newDateTime.toISO()),
+            ),
+        ]);
+    }
+}

package/src/engine/function/system/date/TimeAs.ts

@@ -0,0 +1,64 @@
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { Event } from '../../../model/Event';
+import { EventResult } from '../../../model/EventResult';
+
+import { AbstractDateFunction } from './AbstractDateFunction';
+import { getDateTime } from './common';
+import { Schema } from '../../../json/schema/Schema';
+
+export class TimeAs extends AbstractDateFunction {
+    public static readonly EVENT_TIME_OBJECT_NAME = 'object';
+    public static readonly EVENT_TIME_ARRAY_NAME = 'array';
+
+    private readonly isArray: boolean;
+
+    constructor(isArray: boolean) {
+        super(
+            isArray ? 'TimeAsArray' : 'TimeAsObject',
+            new Event(
+                Event.OUTPUT,
+                MapUtil.of(
+                    isArray ? TimeAs.EVENT_TIME_ARRAY_NAME : TimeAs.EVENT_TIME_OBJECT_NAME,
+                    isArray
+                        ? Schema.ofArray(
+                              TimeAs.EVENT_TIME_ARRAY_NAME,
+                              Schema.ofInteger('timeParts'),
+                          )
+                        : Schema.ofRef(Namespaces.DATE + '.TimeObject'),
+                ),
+            ),
+            AbstractDateFunction.PARAMETER_TIMESTAMP,
+        );
+
+        this.isArray = isArray;
+    }
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        const timestamp = context
+            .getArguments()
+            ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME);
+
+        const dateTime = getDateTime(timestamp).toObject();
+
+        return new FunctionOutput([
+            EventResult.outputOf(
+                MapUtil.of(
+                    this.isArray ? TimeAs.EVENT_TIME_ARRAY_NAME : TimeAs.EVENT_TIME_OBJECT_NAME,
+                    this.isArray
+                        ? [
+                              dateTime.year,
+                              dateTime.month,
+                              dateTime.day,
+                              dateTime.hour,
+                              dateTime.minute,
+                              dateTime.second,
+                              dateTime.millisecond,
+                          ]
+                        : dateTime,
+                ),
+            ),
+        ]);
+    }
+}

package/src/engine/function/system/date/TimestampToEpoch.ts

@@ -0,0 +1,54 @@
+import { DateTime } from 'luxon';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionSignature } from '../../../model/FunctionSignature';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { AbstractFunction } from '../../AbstractFunction';
+import { AbstractDateFunction } from './AbstractDateFunction';
+
+export class TimestampToEpoch extends AbstractFunction {
+    private readonly signature: FunctionSignature;
+    private readonly isSeconds: boolean;
+
+    constructor(name: string, isSeconds: boolean) {
+        super();
+
+        this.isSeconds = isSeconds;
+        this.signature = new FunctionSignature(name)
+            .setNamespace(Namespaces.DATE)
+            .setParameters(
+                new Map([
+                    [
+                        AbstractDateFunction.PARAMETER_TIMESTAMP_NAME,
+                        AbstractDateFunction.PARAMETER_TIMESTAMP,
+                    ],
+                ]),
+            )
+            .setEvents(
+                new Map([
+                    [AbstractDateFunction.EVENT_RESULT_NAME, AbstractDateFunction.EVENT_LONG],
+                ]),
+            );
+    }
+
+    public getSignature(): FunctionSignature {
+        return this.signature;
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        const timestamp = context
+            .getArguments()
+            ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME);
+        const epoch = this.isSeconds
+            ? DateTime.fromISO(timestamp).toSeconds()
+            : DateTime.fromISO(timestamp).toMillis();
+
+        return Promise.resolve(
+            new FunctionOutput([
+                EventResult.outputOf(MapUtil.of(AbstractDateFunction.EVENT_RESULT_NAME, epoch)),
+            ]),
+        );
+    }
+}

package/src/engine/function/system/date/ToDateString.ts

@@ -0,0 +1,49 @@
+import { Schema } from '../../../json/schema/Schema';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { Parameter } from '../../../model/Parameter';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { AbstractDateFunction } from './AbstractDateFunction';
+import { getDateTime } from './common';
+
+export class ToDateString extends AbstractDateFunction {
+    public static readonly PARAMETER_FORMAT_NAME = 'format';
+    public static readonly PARAMETER_LOCALE_NAME = 'locale';
+
+    constructor() {
+        super(
+            'ToDateString',
+            AbstractDateFunction.EVENT_STRING,
+            AbstractDateFunction.PARAMETER_TIMESTAMP,
+            Parameter.of(
+                ToDateString.PARAMETER_FORMAT_NAME,
+                Schema.ofString(ToDateString.PARAMETER_FORMAT_NAME),
+            ),
+            Parameter.of(
+                ToDateString.PARAMETER_LOCALE_NAME,
+                Schema.ofString(ToDateString.PARAMETER_LOCALE_NAME).setDefaultValue(''),
+            ),
+        );
+    }
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        const timestamp = context
+            .getArguments()
+            ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME);
+
+        const dateTime = getDateTime(timestamp);
+
+        const format = context.getArguments()?.get(ToDateString.PARAMETER_FORMAT_NAME);
+        let locale = context.getArguments()?.get(ToDateString.PARAMETER_LOCALE_NAME);
+        if (locale === '') locale = 'system';
+
+        return new FunctionOutput([
+            EventResult.outputOf(
+                MapUtil.of(
+                    AbstractDateFunction.EVENT_RESULT_NAME,
+                    dateTime.toFormat(format, { locale }),
+                ),
+            ),
+        ]);
+    }
+}

package/src/engine/function/system/date/common.ts

@@ -0,0 +1,9 @@
+import { DateTime } from 'luxon';
+
+export function getDateTime(isoTimestamp: string): DateTime {
+    let dt = DateTime.fromISO(isoTimestamp);
+    if (!dt?.isValid) {
+        throw new Error('Invalid ISO timestamp');
+    }
+    return dt;
+}

package/src/engine/function/system/math/MathFunctionRepository.ts

@@ -1,4 +1,6 @@
+import { Schema } from '../../../json/schema/Schema';
 import { SchemaType } from '../../../json/schema/type/SchemaType';
+import { Parameter } from '../../../model/Parameter';
 import { Namespaces } from '../../../namespaces/Namespaces';
 import { Repository } from '../../../Repository';
 import { AbstractFunction } from '../../AbstractFunction';
@@ -9,8 +11,7 @@ import { Hypotenuse } from './Hypotenuse';
 import { Maximum } from './Maximum';
 import { Minimum } from './Minimum';
 import { Random } from './Random';
-import { RandomFloat } from './RandomFloat';
-import { RandomInt } from './RandomInt';
+import { RandomAny } from './RandomAny';
 
 const functionObjectsIndex: { [key: string]: AbstractFunction } = {
     Absolute: new GenericMathFunction(
@@ -55,8 +56,46 @@ const functionObjectsIndex: { [key: string]: AbstractFunction } = {
     Maximum: new Maximum(),
     Minimum: new Minimum(),
     Random: new Random(),
-    RandomFloat: new RandomFloat(),
-    RandomInt: new RandomInt(),
+    RandomFloat: new RandomAny(
+        'RandomFloat',
+        Parameter.of(RandomAny.MIN_VALUE, Schema.ofFloat(RandomAny.MIN_VALUE).setDefaultValue(0)),
+        Parameter.of(
+            RandomAny.MAX_VALUE,
+            Schema.ofFloat(RandomAny.MAX_VALUE).setDefaultValue(2147483647),
+        ),
+        Schema.ofFloat(RandomAny.VALUE),
+        (min, max) => Math.random() * (max - min) + min,
+    ),
+    RandomInt: new RandomAny(
+        'RandomInt',
+        Parameter.of(RandomAny.MIN_VALUE, Schema.ofInteger(RandomAny.MIN_VALUE).setDefaultValue(0)),
+        Parameter.of(
+            RandomAny.MAX_VALUE,
+            Schema.ofInteger(RandomAny.MAX_VALUE).setDefaultValue(2147483647),
+        ),
+        Schema.ofInteger(RandomAny.VALUE),
+        (min, max) => Math.round(Math.random() * (max - min) + min),
+    ),
+    RandomLong: new RandomAny(
+        'RandomLong',
+        Parameter.of(RandomAny.MIN_VALUE, Schema.ofLong(RandomAny.MIN_VALUE).setDefaultValue(0)),
+        Parameter.of(
+            RandomAny.MAX_VALUE,
+            Schema.ofLong(RandomAny.MAX_VALUE).setDefaultValue(Number.MAX_SAFE_INTEGER),
+        ),
+        Schema.ofLong(RandomAny.VALUE),
+        (min, max) => Math.round(Math.random() * (max - min) + min),
+    ),
+    RandomDouble: new RandomAny(
+        'RandomDouble',
+        Parameter.of(RandomAny.MIN_VALUE, Schema.ofDouble(RandomAny.MIN_VALUE).setDefaultValue(0)),
+        Parameter.of(
+            RandomAny.MAX_VALUE,
+            Schema.ofDouble(RandomAny.MAX_VALUE).setDefaultValue(Number.MAX_VALUE),
+        ),
+        Schema.ofDouble(RandomAny.VALUE),
+        (min, max) => Math.random() * (max - min) + min,
+    ),
 };
 
 const filterableNames = Object.values(functionObjectsIndex).map((e) =>