@rulebricks/sdk 1.0.0 → 1.1.0

package/dist/forge/operators.js

@@ -1,938 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ListField = exports.StringField = exports.DateField = exports.NumberField = exports.BooleanField = exports.Argument = void 0;
-const types_js_1 = require("./types.js");
-const values_js_1 = require("./values.js");
-class Argument {
-    constructor(value, expectedType) {
-        this.value = value;
-        this.expectedType = expectedType;
-        this.validateType();
-    }
-    validateType() {
-        if (this.value instanceof values_js_1.DynamicValue) {
-            if (this.value.valueType !== this.expectedType) {
-                throw new types_js_1.TypeMismatchError(`Dynamic value '${this.value.name}' has type ${this.value.valueType}, ` +
-                    `but ${this.expectedType} was expected`);
-            }
-        }
-        else {
-            const expectedJsType = this.getExpectedJsType();
-            if (!(typeof this.value === expectedJsType || (expectedJsType === "object" && Array.isArray(this.value)))) {
-                const actualType = typeof this.value;
-                throw new types_js_1.TypeMismatchError(`Value ${this.value} has type ${actualType}, ` + `but ${this.expectedType} was expected`);
-            }
-        }
-    }
-    getExpectedJsType() {
-        switch (this.expectedType) {
-            case types_js_1.DynamicValueType.STRING:
-                return "string";
-            case types_js_1.DynamicValueType.NUMBER:
-                return "number";
-            case types_js_1.DynamicValueType.BOOLEAN:
-                return "boolean";
-            case types_js_1.DynamicValueType.DATE:
-                return "object";
-            case types_js_1.DynamicValueType.LIST:
-            case types_js_1.DynamicValueType.OBJECT:
-                return "object";
-            default:
-                throw new Error(`Unknown type: ${this.expectedType}`);
-        }
-    }
-    toDict() {
-        if (this.value instanceof values_js_1.DynamicValue) {
-            return this.value.toDict();
-        }
-        return this.value;
-    }
-    static process(arg, expectedType) {
-        if (arg instanceof Argument) {
-            return arg.toDict();
-        }
-        else if (arg instanceof values_js_1.DynamicValue) {
-            return arg.toDict();
-        }
-        else if (Array.isArray(arg)) {
-            return arg.map((item) => this.process(item, expectedType));
-        }
-        else if (typeof arg === "object" && arg !== null) {
-            const result = {};
-            for (const [key, value] of Object.entries(arg)) {
-                result[key] = this.process(value, expectedType);
-            }
-            return result;
-        }
-        return arg;
-    }
-    toString() {
-        if (this.value instanceof values_js_1.DynamicValue) {
-            return `<${this.value.name.toUpperCase()}>`;
-        }
-        return `${this.value}`;
-    }
-}
-exports.Argument = Argument;
-class BooleanField {
-    constructor(name, description = "", defaultValue = false) {
-        this.type = types_js_1.RuleType.BOOLEAN;
-        this.name = name;
-        this.description = description;
-        this.defaultValue = defaultValue;
-        this.operators = {
-            any: { name: "any", args: [], description: "Match any boolean value", skipTypecheck: true },
-            is_true: { name: "is true", args: [], description: "Check if value is true" },
-            is_false: { name: "is false", args: [], description: "Check if value is false" },
-        };
-    }
-    equals(value) {
-        const opName = value ? "is true" : "is false";
-        return [opName, []];
-    }
-}
-exports.BooleanField = BooleanField;
-class NumberField {
-    constructor(name, description = "", defaultValue = 0) {
-        this.type = types_js_1.RuleType.NUMBER;
-        this.name = name;
-        this.description = description;
-        this.defaultValue = defaultValue;
-        this.operators = {
-            any: { name: "any", args: [], description: "Match any numeric value", skipTypecheck: true },
-            equals: {
-                name: "equals",
-                args: [{ name: "value", type: "number", description: "Number that value must equal" }],
-            },
-            does_not_equal: {
-                name: "does not equal",
-                args: [{ name: "value", type: "number", description: "Number that value must not equal" }],
-            },
-            greater_than: {
-                name: "greater than",
-                args: [{ name: "bound", type: "number", description: "Number that value must be greater than" }],
-            },
-            less_than: {
-                name: "less than",
-                args: [{ name: "bound", type: "number", description: "Number that value must be less than" }],
-            },
-            greater_than_or_equal: {
-                name: "greater than or equal to",
-                args: [
-                    {
-                        name: "bound",
-                        type: "number",
-                        description: "Number that value must be greater than or equal to",
-                    },
-                ],
-            },
-            less_than_or_equal: {
-                name: "less than or equal to",
-                args: [
-                    { name: "bound", type: "number", description: "Number that value must be less than or equal to" },
-                ],
-            },
-            between: {
-                name: "between",
-                args: [
-                    {
-                        name: "start",
-                        type: "number",
-                        description: "Number that value must be greater than or equal to",
-                        placeholder: "Start",
-                    },
-                    {
-                        name: "end",
-                        type: "number",
-                        description: "Number that value must be less than or equal to",
-                        placeholder: "End",
-                    },
-                ],
-                validate: (args) => args[0] < args[1],
-            },
-            not_between: {
-                name: "not between",
-                args: [
-                    {
-                        name: "start",
-                        type: "number",
-                        description: "Number that value must be less than",
-                        placeholder: "Start",
-                    },
-                    {
-                        name: "end",
-                        type: "number",
-                        description: "Number that value must be greater than",
-                        placeholder: "End",
-                    },
-                ],
-                validate: (args) => args[0] < args[1],
-            },
-            is_even: { name: "is even", args: [], description: "Check if value is even" },
-            is_odd: { name: "is odd", args: [], description: "Check if value is odd" },
-            is_positive: { name: "is positive", args: [], description: "Check if value is greater than zero" },
-            is_negative: { name: "is negative", args: [], description: "Check if value is less than zero" },
-            is_zero: { name: "is zero", args: [], description: "Check if value equals zero" },
-            is_not_zero: { name: "is not zero", args: [], description: "Check if value does not equal zero" },
-            is_multiple_of: {
-                name: "is a multiple of",
-                args: [{ name: "multiple", type: "number", description: "Number that value must be a multiple of" }],
-            },
-            is_not_multiple_of: {
-                name: "is not a multiple of",
-                args: [
-                    { name: "multiple", type: "number", description: "Number that value must not be a multiple of" },
-                ],
-            },
-            is_power_of: {
-                name: "is a power of",
-                args: [{ name: "base", type: "number", description: "The base number" }],
-                validate: (args) => args[0] > 0,
-            },
-        };
-    }
-    equals(value) {
-        return ["equals", [new Argument(value, types_js_1.DynamicValueType.NUMBER).toDict()]];
-    }
-    not_equals(value) {
-        return ["does not equal", [new Argument(value, types_js_1.DynamicValueType.NUMBER).toDict()]];
-    }
-    greater_than(value) {
-        return ["greater than", [new Argument(value, types_js_1.DynamicValueType.NUMBER).toDict()]];
-    }
-    less_than(value) {
-        return ["less than", [new Argument(value, types_js_1.DynamicValueType.NUMBER).toDict()]];
-    }
-    greater_than_or_equal(value) {
-        return ["greater than or equal to", [new Argument(value, types_js_1.DynamicValueType.NUMBER).toDict()]];
-    }
-    less_than_or_equal(value) {
-        return ["less than or equal to", [new Argument(value, types_js_1.DynamicValueType.NUMBER).toDict()]];
-    }
-    between(start, end) {
-        const startArg = new Argument(start, types_js_1.DynamicValueType.NUMBER);
-        const endArg = new Argument(end, types_js_1.DynamicValueType.NUMBER);
-        if (!(start instanceof values_js_1.DynamicValue) && !(end instanceof values_js_1.DynamicValue)) {
-            const op = this.operators["between"];
-            if (op.validate && !op.validate([start, end])) {
-                throw new Error(`Invalid range for between: start (${start}) must be less than end (${end})`);
-            }
-        }
-        return ["between", [startArg.toDict(), endArg.toDict()]];
-    }
-    not_between(start, end) {
-        const startArg = new Argument(start, types_js_1.DynamicValueType.NUMBER);
-        const endArg = new Argument(end, types_js_1.DynamicValueType.NUMBER);
-        if (!(start instanceof values_js_1.DynamicValue) && !(end instanceof values_js_1.DynamicValue)) {
-            const op = this.operators["not_between"];
-            if (op.validate && !op.validate([start, end])) {
-                throw new Error(`Invalid range for not between: start (${start}) must be less than end (${end})`);
-            }
-        }
-        return ["not between", [startArg.toDict(), endArg.toDict()]];
-    }
-    is_even() {
-        return ["is even", []];
-    }
-    is_odd() {
-        return ["is odd", []];
-    }
-    is_positive() {
-        return ["is positive", []];
-    }
-    is_negative() {
-        return ["is negative", []];
-    }
-    is_zero() {
-        return ["is zero", []];
-    }
-    is_not_zero() {
-        return ["is not zero", []];
-    }
-    is_multiple_of(value) {
-        return ["is a multiple of", [new Argument(value, types_js_1.DynamicValueType.NUMBER).toDict()]];
-    }
-    is_not_multiple_of(value) {
-        return ["is not a multiple of", [new Argument(value, types_js_1.DynamicValueType.NUMBER).toDict()]];
-    }
-    is_power_of(base) {
-        if (!(base instanceof values_js_1.DynamicValue)) {
-            const op = this.operators["is_power_of"];
-            if (op.validate && !op.validate([base])) {
-                throw new Error(`Invalid base for is power of: ${base}. Base must be positive.`);
-            }
-        }
-        return ["is a power of", [new Argument(base, types_js_1.DynamicValueType.NUMBER).toDict()]];
-    }
-}
-exports.NumberField = NumberField;
-class DateField {
-    constructor(name, description = "", defaultValue = null) {
-        this.type = types_js_1.RuleType.DATE;
-        this.name = name;
-        this.description = description;
-        this.defaultValue = defaultValue || new Date();
-        this.operators = {
-            any: { name: "any", args: [], description: "Match any date value", skipTypecheck: true },
-            is_past: { name: "is in the past", args: [], description: "Date is in the past" },
-            is_future: { name: "is in the future", args: [], description: "Date is in the future" },
-            days_ago: {
-                name: "days ago",
-                args: [{ name: "days", type: "number", description: "Number of days ago that the date is equal to" }],
-            },
-            less_than_days_ago: {
-                name: "is less than N days ago",
-                args: [
-                    {
-                        name: "days",
-                        type: "number",
-                        description: "Number of days ago that the date is less than or equal to",
-                    },
-                ],
-            },
-            more_than_days_ago: {
-                name: "is more than N days ago",
-                args: [
-                    {
-                        name: "days",
-                        type: "number",
-                        description: "Number of days ago that the date is more than or equal to",
-                    },
-                ],
-            },
-            days_from_now: {
-                name: "days from now",
-                args: [
-                    { name: "days", type: "number", description: "Number of days from now that the date is equal to" },
-                ],
-            },
-            less_than_days_from_now: {
-                name: "is less than N days from now",
-                args: [
-                    {
-                        name: "days",
-                        type: "number",
-                        description: "Number of days from now that the date is less than or equal to",
-                    },
-                ],
-            },
-            more_than_days_from_now: {
-                name: "is more than N days from now",
-                args: [
-                    {
-                        name: "days",
-                        type: "number",
-                        description: "Number of days from now that the date is more than or equal to",
-                    },
-                ],
-            },
-            is_today: { name: "is today", args: [], description: "Date is today" },
-            is_this_week: { name: "is this week", args: [], description: "Date is in the current week" },
-            is_this_month: { name: "is this month", args: [], description: "Date is in the current month" },
-            is_this_year: { name: "is this year", args: [], description: "Date is in the current year" },
-            is_next_week: { name: "is next week", args: [], description: "Date is in the next week" },
-            is_next_month: { name: "is next month", args: [], description: "Date is in the next month" },
-            is_next_year: { name: "is next year", args: [], description: "Date is in the next year" },
-            is_last_week: { name: "is last week", args: [], description: "Date is in the previous week" },
-            is_last_month: { name: "is last month", args: [], description: "Date is in the previous month" },
-            is_last_year: { name: "is last year", args: [], description: "Date is in the previous year" },
-            after: {
-                name: "after",
-                args: [{ name: "date", type: "date", description: "Date that value must be after" }],
-            },
-            on_or_after: {
-                name: "on or after",
-                args: [{ name: "date", type: "date", description: "Date that value must be on or after" }],
-            },
-            before: {
-                name: "before",
-                args: [{ name: "date", type: "date", description: "Date that value must be before" }],
-            },
-            on_or_before: {
-                name: "on or before",
-                args: [{ name: "date", type: "date", description: "Date that value must be on or before" }],
-            },
-            between: {
-                name: "between",
-                args: [
-                    { name: "start", type: "date", description: "Date that value must be after", placeholder: "From" },
-                    { name: "end", type: "date", description: "Date that value must be before", placeholder: "To" },
-                ],
-            },
-            not_between: {
-                name: "not between",
-                args: [
-                    { name: "start", type: "date", description: "Date that value must be before", placeholder: "From" },
-                    { name: "end", type: "date", description: "Date that value must be after", placeholder: "To" },
-                ],
-            },
-        };
-    }
-    is_past() {
-        return ["is in the past", []];
-    }
-    is_future() {
-        return ["is in the future", []];
-    }
-    days_ago(days) {
-        return ["days ago", [new Argument(days, types_js_1.DynamicValueType.NUMBER).toDict()]];
-    }
-    less_than_days_ago(days) {
-        return ["is less than N days ago", [new Argument(days, types_js_1.DynamicValueType.NUMBER).toDict()]];
-    }
-    more_than_days_ago(days) {
-        return ["is more than N days ago", [new Argument(days, types_js_1.DynamicValueType.NUMBER).toDict()]];
-    }
-    days_from_now(days) {
-        return ["days from now", [new Argument(days, types_js_1.DynamicValueType.NUMBER).toDict()]];
-    }
-    less_than_days_from_now(days) {
-        return ["is less than N days from now", [new Argument(days, types_js_1.DynamicValueType.NUMBER).toDict()]];
-    }
-    more_than_days_from_now(days) {
-        return ["is more than N days from now", [new Argument(days, types_js_1.DynamicValueType.NUMBER).toDict()]];
-    }
-    is_today() {
-        return ["is today", []];
-    }
-    is_this_week() {
-        return ["is this week", []];
-    }
-    is_this_month() {
-        return ["is this month", []];
-    }
-    is_this_year() {
-        return ["is this year", []];
-    }
-    is_next_week() {
-        return ["is next week", []];
-    }
-    is_next_month() {
-        return ["is next month", []];
-    }
-    is_next_year() {
-        return ["is next year", []];
-    }
-    is_last_week() {
-        return ["is last week", []];
-    }
-    is_last_month() {
-        return ["is last month", []];
-    }
-    is_last_year() {
-        return ["is last year", []];
-    }
-    after(date) {
-        return ["after", [new Argument(date, types_js_1.DynamicValueType.DATE).toDict()]];
-    }
-    on_or_after(date) {
-        return ["on or after", [new Argument(date, types_js_1.DynamicValueType.DATE).toDict()]];
-    }
-    before(date) {
-        return ["before", [new Argument(date, types_js_1.DynamicValueType.DATE).toDict()]];
-    }
-    on_or_before(date) {
-        return ["on or before", [new Argument(date, types_js_1.DynamicValueType.DATE).toDict()]];
-    }
-    between(start, end) {
-        return [
-            "between",
-            [new Argument(start, types_js_1.DynamicValueType.DATE).toDict(), new Argument(end, types_js_1.DynamicValueType.DATE).toDict()],
-        ];
-    }
-}
-exports.DateField = DateField;
-class StringField {
-    constructor(name, description = "", defaultValue = "") {
-        this.type = types_js_1.RuleType.STRING;
-        this.name = name;
-        this.description = description;
-        this.defaultValue = defaultValue;
-        this.operators = {
-            any: { name: "any", args: [], description: "Match any string value", skipTypecheck: true },
-            contains: {
-                name: "contains",
-                args: [
-                    {
-                        name: "value",
-                        type: "string",
-                        description: "The value to search for within the string",
-                        validate: (x) => x.length > 0,
-                    },
-                ],
-            },
-            does_not_contain: {
-                name: "does not contain",
-                args: [
-                    {
-                        name: "value",
-                        type: "string",
-                        description: "The value to search for within the string",
-                        validate: (x) => x.length > 0,
-                    },
-                ],
-            },
-            equals: {
-                name: "equals",
-                args: [{ name: "value", type: "string", description: "The value to compare against" }],
-            },
-            does_not_equal: {
-                name: "does not equal",
-                args: [{ name: "value", type: "string", description: "The value to compare against" }],
-            },
-            is_empty: { name: "is empty", args: [], description: "Check if string is empty" },
-            is_not_empty: { name: "is not empty", args: [], description: "Check if string is not empty" },
-            starts_with: {
-                name: "starts with",
-                args: [
-                    {
-                        name: "value",
-                        type: "string",
-                        description: "The value the string should start with",
-                        validate: (v) => v.length > 0,
-                    },
-                ],
-            },
-            ends_with: {
-                name: "ends with",
-                args: [
-                    {
-                        name: "value",
-                        type: "string",
-                        description: "The value the string should end with",
-                        validate: (v) => v.length > 0,
-                    },
-                ],
-            },
-            is_included_in: {
-                name: "is included in",
-                args: [
-                    {
-                        name: "value",
-                        type: "list",
-                        description: "A list of values the string should be in",
-                        validate: (v) => v.length > 0,
-                    },
-                ],
-            },
-            is_not_included_in: {
-                name: "is not included in",
-                args: [
-                    {
-                        name: "value",
-                        type: "list",
-                        description: "A list of values the string should not be in",
-                        validate: (v) => v.length > 0,
-                    },
-                ],
-            },
-            matches_regex: {
-                name: "matches RegEx",
-                args: [
-                    {
-                        name: "regex",
-                        type: "string",
-                        description: "The regex the string should match",
-                        validate: (v) => v.length > 0,
-                    },
-                ],
-            },
-            does_not_match_regex: {
-                name: "does not match RegEx",
-                args: [
-                    {
-                        name: "regex",
-                        type: "string",
-                        description: "The regex the string should not match",
-                        validate: (v) => v.length > 0,
-                    },
-                ],
-            },
-            is_valid_email: {
-                name: "is a valid email address",
-                args: [],
-                description: "Check if string is a valid email address",
-            },
-            is_not_valid_email: {
-                name: "is not a valid email address",
-                args: [],
-                description: "Check if string is not a valid email address",
-            },
-            is_valid_url: {
-                name: "is a valid URL",
-                args: [],
-                description: "Check if string is a valid URL",
-            },
-            is_not_valid_url: {
-                name: "is not a valid URL",
-                args: [],
-                description: "Check if string is not a valid URL",
-            },
-            is_valid_ip: {
-                name: "is a valid IP address",
-                args: [],
-                description: "Check if string is a valid IP address",
-            },
-            is_not_valid_ip: {
-                name: "is not a valid IP address",
-                args: [],
-                description: "Check if string is not a valid IP address",
-            },
-            is_uppercase: {
-                name: "is uppercase",
-                args: [],
-                description: "Check if string is all uppercase",
-            },
-            is_lowercase: {
-                name: "is lowercase",
-                args: [],
-                description: "Check if string is all lowercase",
-            },
-            is_numeric: {
-                name: "is numeric",
-                args: [],
-                description: "Check if string contains only numeric characters",
-            },
-            contains_only_digits: {
-                name: "contains only digits",
-                args: [],
-                description: "Check if string contains only digits",
-            },
-            contains_only_letters: {
-                name: "contains only letters",
-                args: [],
-                description: "Check if string contains only letters",
-            },
-            contains_only_digits_and_letters: {
-                name: "contains only digits and letters",
-                args: [],
-                description: "Check if string contains only digits and letters",
-            },
-        };
-    }
-    contains(value) {
-        const arg = new Argument(value, types_js_1.DynamicValueType.STRING);
-        if (!(value instanceof values_js_1.DynamicValue)) {
-            const op = this.operators["contains"];
-            if (op.args[0].validate && !op.args[0].validate(value)) {
-                throw new Error(`Invalid value for contains: ${value}`);
-            }
-        }
-        return ["contains", [arg.toDict()]];
-    }
-    not_contains(value) {
-        const arg = new Argument(value, types_js_1.DynamicValueType.STRING);
-        if (!(value instanceof values_js_1.DynamicValue)) {
-            const op = this.operators["does_not_contain"];
-            if (op.args[0].validate && !op.args[0].validate(value)) {
-                throw new Error(`Invalid value for does not contain: ${value}`);
-            }
-        }
-        return ["does not contain", [arg.toDict()]];
-    }
-    equals(value) {
-        return ["equals", [new Argument(value, types_js_1.DynamicValueType.STRING).toDict()]];
-    }
-    not_equals(value) {
-        return ["does not equal", [new Argument(value, types_js_1.DynamicValueType.STRING).toDict()]];
-    }
-    is_empty() {
-        return ["is empty", []];
-    }
-    is_not_empty() {
-        return ["is not empty", []];
-    }
-    starts_with(value) {
-        const arg = new Argument(value, types_js_1.DynamicValueType.STRING);
-        if (!(value instanceof values_js_1.DynamicValue)) {
-            const op = this.operators["starts_with"];
-            if (op.args[0].validate && !op.args[0].validate(value)) {
-                throw new Error(`Invalid value for starts with: ${value}`);
-            }
-        }
-        return ["starts with", [arg.toDict()]];
-    }
-    ends_with(value) {
-        const arg = new Argument(value, types_js_1.DynamicValueType.STRING);
-        if (!(value instanceof values_js_1.DynamicValue)) {
-            const op = this.operators["ends_with"];
-            if (op.args[0].validate && !op.args[0].validate(value)) {
-                throw new Error(`Invalid value for ends with: ${value}`);
-            }
-        }
-        return ["ends with", [arg.toDict()]];
-    }
-    is_included_in(values) {
-        if (values instanceof values_js_1.DynamicValue) {
-            if (values.valueType !== types_js_1.DynamicValueType.LIST) {
-                throw new types_js_1.TypeMismatchError(`Dynamic value '${values.name}' has type ${values.valueType}, but list was expected`);
-            }
-            return ["is included in", [new Argument(values, types_js_1.DynamicValueType.LIST).toDict()]];
-        }
-        const op = this.operators["is_included_in"];
-        if (op.args[0].validate && !op.args[0].validate(values)) {
-            throw new Error("List must not be empty");
-        }
-        return ["is included in", [values.map((v) => new Argument(v, types_js_1.DynamicValueType.STRING).toDict())]];
-    }
-    matches_regex(pattern) {
-        const arg = new Argument(pattern, types_js_1.DynamicValueType.STRING);
-        if (!(pattern instanceof values_js_1.DynamicValue)) {
-            const op = this.operators["matches_regex"];
-            if (op.args[0].validate && !op.args[0].validate(pattern)) {
-                throw new Error(`Invalid regex pattern: ${pattern}`);
-            }
-        }
-        return ["matches RegEx", [arg.toDict()]];
-    }
-    not_matches_regex(pattern) {
-        const arg = new Argument(pattern, types_js_1.DynamicValueType.STRING);
-        if (!(pattern instanceof values_js_1.DynamicValue)) {
-            const op = this.operators["does_not_match_regex"];
-            if (op.args[0].validate && !op.args[0].validate(pattern)) {
-                throw new Error(`Invalid regex pattern: ${pattern}`);
-            }
-        }
-        return ["does not match RegEx", [arg.toDict()]];
-    }
-    is_email() {
-        return ["is a valid email address", []];
-    }
-    is_not_email() {
-        return ["is not a valid email address", []];
-    }
-    is_url() {
-        return ["is a valid URL", []];
-    }
-    is_not_url() {
-        return ["is not a valid URL", []];
-    }
-    is_ip() {
-        return ["is a valid IP address", []];
-    }
-    is_not_ip() {
-        return ["is not a valid IP address", []];
-    }
-    is_uppercase() {
-        return ["is uppercase", []];
-    }
-    is_lowercase() {
-        return ["is lowercase", []];
-    }
-    is_numeric() {
-        return ["is numeric", []];
-    }
-    contains_only_digits() {
-        return ["contains only digits", []];
-    }
-    contains_only_letters() {
-        return ["contains only letters", []];
-    }
-    contains_only_digits_and_letters() {
-        return ["contains only digits and letters", []];
-    }
-}
-exports.StringField = StringField;
-class ListField {
-    constructor(name, description = "", defaultValue = []) {
-        this.type = types_js_1.RuleType.LIST;
-        this.name = name;
-        this.description = description;
-        this.defaultValue = defaultValue;
-        this.operators = {
-            any: { name: "any", args: [], description: "Match any list value", skipTypecheck: true },
-            contains: {
-                name: "contains",
-                args: [{ name: "value", type: "generic", description: "Value that must be contained in the list" }],
-            },
-            is_empty: { name: "is empty", args: [], description: "Check if list is empty" },
-            is_not_empty: { name: "is not empty", args: [], description: "Check if list is not empty" },
-            is_of_length: {
-                name: "is of length",
-                args: [{ name: "length", type: "number", description: "Length that the list must be" }],
-            },
-            is_not_of_length: {
-                name: "is not of length",
-                args: [{ name: "length", type: "number", description: "Length that the list must not be" }],
-            },
-            is_longer_than: {
-                name: "is longer than",
-                args: [{ name: "length", type: "number", description: "Length that the list must be longer than" }],
-            },
-            is_shorter_than: {
-                name: "is shorter than",
-                args: [{ name: "length", type: "number", description: "Length that the list must be shorter than" }],
-            },
-            contains_all_of: {
-                name: "contains all of",
-                args: [
-                    { name: "values", type: "list", description: "List of values that must be contained in the list" },
-                ],
-            },
-            contains_any_of: {
-                name: "contains any of",
-                args: [
-                    { name: "values", type: "list", description: "List of values that might be contained in the list" },
-                ],
-            },
-            contains_none_of: {
-                name: "contains none of",
-                args: [
-                    {
-                        name: "values",
-                        type: "list",
-                        description: "List of values that must not be contained in the list",
-                    },
-                ],
-            },
-            does_not_contain: {
-                name: "does not contain",
-                args: [{ name: "value", type: "generic", description: "Value that must not be contained in the list" }],
-            },
-            is_equal_to: {
-                name: "is equal to",
-                args: [{ name: "list", type: "list", description: "Value that the list must be equal to" }],
-            },
-            is_not_equal_to: {
-                name: "is not equal to",
-                args: [{ name: "list", type: "list", description: "Value that the list must not be equal to" }],
-            },
-            contains_duplicates: {
-                name: "contains duplicates",
-                args: [],
-                description: "Check if list contains duplicate values",
-            },
-            does_not_contain_duplicates: {
-                name: "does not contain duplicates",
-                args: [],
-                description: "Check if list does not contain duplicate values",
-            },
-            contains_object_with_key_value: {
-                name: "contains object with key & value",
-                args: [
-                    { name: "key", type: "string", description: "Key of any object contained in the list" },
-                    { name: "value", type: "generic", description: "Value that the key must be equal to" },
-                ],
-            },
-            has_unique_elements: {
-                name: "has unique elements",
-                args: [],
-                description: "Check if all elements in the list are unique",
-            },
-            is_sublist_of: {
-                name: "is a sublist of",
-                args: [{ name: "superlist", type: "list", description: "List that should contain this list" }],
-            },
-            is_superlist_of: {
-                name: "is a superlist of",
-                args: [{ name: "sublist", type: "list", description: "List that should be contained in this list" }],
-            },
-        };
-    }
-    contains(value) {
-        return ["contains", [new Argument(value, types_js_1.DynamicValueType.OBJECT).toDict()]];
-    }
-    is_empty() {
-        return ["is empty", []];
-    }
-    is_not_empty() {
-        return ["is not empty", []];
-    }
-    length_equals(length) {
-        return ["is of length", [new Argument(length, types_js_1.DynamicValueType.NUMBER).toDict()]];
-    }
-    length_not_equals(length) {
-        return ["is not of length", [new Argument(length, types_js_1.DynamicValueType.NUMBER).toDict()]];
-    }
-    longer_than(length) {
-        return ["is longer than", [new Argument(length, types_js_1.DynamicValueType.NUMBER).toDict()]];
-    }
-    shorter_than(length) {
-        return ["is shorter than", [new Argument(length, types_js_1.DynamicValueType.NUMBER).toDict()]];
-    }
-    contains_all(values) {
-        if (values instanceof values_js_1.DynamicValue) {
-            if (values.valueType !== types_js_1.DynamicValueType.LIST) {
-                throw new types_js_1.TypeMismatchError(`Dynamic value '${values.name}' has type ${values.valueType}, but list was expected`);
-            }
-            return ["contains all of", [new Argument(values, types_js_1.DynamicValueType.LIST).toDict()]];
-        }
-        return ["contains all of", [values.map((v) => new Argument(v, types_js_1.DynamicValueType.OBJECT).toDict())]];
-    }
-    contains_any(values) {
-        if (values instanceof values_js_1.DynamicValue) {
-            if (values.valueType !== types_js_1.DynamicValueType.LIST) {
-                throw new types_js_1.TypeMismatchError(`Dynamic value '${values.name}' has type ${values.valueType}, but list was expected`);
-            }
-            return ["contains any of", [new Argument(values, types_js_1.DynamicValueType.LIST).toDict()]];
-        }
-        return ["contains any of", [values.map((v) => new Argument(v, types_js_1.DynamicValueType.OBJECT).toDict())]];
-    }
-    contains_none(values) {
-        if (values instanceof values_js_1.DynamicValue) {
-            if (values.valueType !== types_js_1.DynamicValueType.LIST) {
-                throw new types_js_1.TypeMismatchError(`Dynamic value '${values.name}' has type ${values.valueType}, but list was expected`);
-            }
-            return ["contains none of", [new Argument(values, types_js_1.DynamicValueType.LIST).toDict()]];
-        }
-        return ["contains none of", [values.map((v) => new Argument(v, types_js_1.DynamicValueType.OBJECT).toDict())]];
-    }
-    not_contains(value) {
-        return ["does not contain", [new Argument(value, types_js_1.DynamicValueType.OBJECT).toDict()]];
-    }
-    equals(other) {
-        if (other instanceof values_js_1.DynamicValue) {
-            if (other.valueType !== types_js_1.DynamicValueType.LIST) {
-                throw new types_js_1.TypeMismatchError(`Dynamic value '${other.name}' has type ${other.valueType}, but list was expected`);
-            }
-            return ["is equal to", [new Argument(other, types_js_1.DynamicValueType.LIST).toDict()]];
-        }
-        return ["is equal to", [other.map((v) => new Argument(v, types_js_1.DynamicValueType.OBJECT).toDict())]];
-    }
-    not_equals(other) {
-        if (other instanceof values_js_1.DynamicValue) {
-            if (other.valueType !== types_js_1.DynamicValueType.LIST) {
-                throw new types_js_1.TypeMismatchError(`Dynamic value '${other.name}' has type ${other.valueType}, but list was expected`);
-            }
-            return ["is not equal to", [new Argument(other, types_js_1.DynamicValueType.LIST).toDict()]];
-        }
-        return ["is not equal to", [other.map((v) => new Argument(v, types_js_1.DynamicValueType.OBJECT).toDict())]];
-    }
-    has_duplicates() {
-        return ["contains duplicates", []];
-    }
-    no_duplicates() {
-        return ["does not contain duplicates", []];
-    }
-    contains_object_with_key_value(key, value) {
-        return [
-            "contains object with key & value",
-            [
-                new Argument(key, types_js_1.DynamicValueType.STRING).toDict(),
-                new Argument(value, types_js_1.DynamicValueType.OBJECT).toDict(),
-            ],
-        ];
-    }
-    has_unique_elements() {
-        return ["has unique elements", []];
-    }
-    is_sublist_of(superlist) {
-        if (superlist instanceof values_js_1.DynamicValue) {
-            if (superlist.valueType !== types_js_1.DynamicValueType.LIST) {
-                throw new types_js_1.TypeMismatchError(`Dynamic value '${superlist.name}' has type ${superlist.valueType}, but list was expected`);
-            }
-            return ["is a sublist of", [new Argument(superlist, types_js_1.DynamicValueType.LIST).toDict()]];
-        }
-        return ["is a sublist of", [superlist.map((v) => new Argument(v, types_js_1.DynamicValueType.OBJECT).toDict())]];
-    }
-    is_superlist_of(sublist) {
-        if (sublist instanceof values_js_1.DynamicValue) {
-            if (sublist.valueType !== types_js_1.DynamicValueType.LIST) {
-                throw new types_js_1.TypeMismatchError(`Dynamic value '${sublist.name}' has type ${sublist.valueType}, but list was expected`);
-            }
-            return ["is a superlist of", [new Argument(sublist, types_js_1.DynamicValueType.LIST).toDict()]];
-        }
-        return ["is a superlist of", [sublist.map((v) => new Argument(v, types_js_1.DynamicValueType.OBJECT).toDict())]];
-    }
-}
-exports.ListField = ListField;