@rulebricks/sdk 1.1.0 → 1.2.0

package/dist/core/schemas/builders/schema-utils/stringifyValidationErrors.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringifyValidationError = stringifyValidationError;
+exports.stringifyValidationError = void 0;
 function stringifyValidationError(error) {
     if (error.path.length === 0) {
         return error.message;
     }
     return `${error.path.join(" -> ")}: ${error.message}`;
 }
+exports.stringifyValidationError = stringifyValidationError;

package/dist/core/schemas/builders/set/index.d.ts

@@ -1,3 +1 @@
-export var __esModule: boolean;
-export var set: typeof set_1.set;
-import set_1 = require("./set");
+export { set } from "./set";

package/dist/core/schemas/builders/set/set.d.ts

@@ -1,4 +1,2 @@
-export var __esModule: boolean;
-export function set(schema: any): Schema_1.BaseSchema<any, any> & schema_utils_1.SchemaUtils<any[], Set<any>>;
-import Schema_1 = require("../../Schema");
-import schema_utils_1 = require("../schema-utils");
+import { Schema } from "../../Schema";
+export declare function set<Raw, Parsed>(schema: Schema<Raw, Parsed>): Schema<Raw[], Set<Parsed>>;

package/dist/core/schemas/builders/set/set.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.set = set;
+exports.set = void 0;
 const Schema_1 = require("../../Schema");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
@@ -41,3 +41,4 @@ function set(schema) {
     };
     return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
+exports.set = set;

package/dist/core/schemas/builders/undiscriminated-union/index.d.ts

@@ -1,3 +1,2 @@
-export var __esModule: boolean;
-export var undiscriminatedUnion: typeof undiscriminatedUnion_1.undiscriminatedUnion;
-import undiscriminatedUnion_1 = require("./undiscriminatedUnion");
+export type { inferParsedUnidiscriminatedUnionSchema, inferRawUnidiscriminatedUnionSchema, UndiscriminatedUnionSchema, } from "./types";
+export { undiscriminatedUnion } from "./undiscriminatedUnion";

package/dist/core/schemas/builders/undiscriminated-union/types.d.ts

@@ -1 +1,4 @@
-export var __esModule: boolean;
+import { Schema, inferParsed, inferRaw } from "../../Schema";
+export declare type UndiscriminatedUnionSchema<Schemas extends [...Schema[]]> = Schema<inferRawUnidiscriminatedUnionSchema<Schemas>, inferParsedUnidiscriminatedUnionSchema<Schemas>>;
+export declare type inferRawUnidiscriminatedUnionSchema<Schemas extends [...Schema[]]> = inferRaw<Schemas[number]>;
+export declare type inferParsedUnidiscriminatedUnionSchema<Schemas extends [...Schema[]]> = inferParsed<Schemas[number]>;

package/dist/core/schemas/builders/undiscriminated-union/undiscriminatedUnion.d.ts

@@ -1,7 +1,3 @@
-export var __esModule: boolean;
-export function undiscriminatedUnion(schemas: any): {
-    parse: (raw: any, opts: any) => any;
-    json: (parsed: any, opts: any) => any;
-    getType: () => "undiscriminatedUnion";
-} & schema_utils_1.SchemaUtils<any, any>;
-import schema_utils_1 = require("../schema-utils");
+import { Schema } from "../../Schema";
+import { inferParsedUnidiscriminatedUnionSchema, inferRawUnidiscriminatedUnionSchema } from "./types";
+export declare function undiscriminatedUnion<Schemas extends [Schema<any, any>, ...Schema<any, any>[]]>(schemas: Schemas): Schema<inferRawUnidiscriminatedUnionSchema<Schemas>, inferParsedUnidiscriminatedUnionSchema<Schemas>>;

package/dist/core/schemas/builders/undiscriminated-union/undiscriminatedUnion.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.undiscriminatedUnion = undiscriminatedUnion;
+exports.undiscriminatedUnion = void 0;
 const Schema_1 = require("../../Schema");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
 const schema_utils_1 = require("../schema-utils");
@@ -16,6 +16,7 @@ function undiscriminatedUnion(schemas) {
     };
     return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
+exports.undiscriminatedUnion = undiscriminatedUnion;
 function validateAndTransformUndiscriminatedUnion(transform, schemas, opts) {
     const errors = [];
     for (const [index, schema] of schemas.entries()) {

package/dist/core/schemas/builders/union/discriminant.d.ts

@@ -1,5 +1,5 @@
-export var __esModule: boolean;
-export function discriminant(parsedDiscriminant: any, rawDiscriminant: any): {
-    parsedDiscriminant: any;
-    rawDiscriminant: any;
-};
+export declare function discriminant<RawDiscriminant extends string, ParsedDiscriminant extends string>(parsedDiscriminant: ParsedDiscriminant, rawDiscriminant: RawDiscriminant): Discriminant<RawDiscriminant, ParsedDiscriminant>;
+export interface Discriminant<RawDiscriminant extends string, ParsedDiscriminant extends string> {
+    parsedDiscriminant: ParsedDiscriminant;
+    rawDiscriminant: RawDiscriminant;
+}

package/dist/core/schemas/builders/union/discriminant.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.discriminant = discriminant;
+exports.discriminant = void 0;
 function discriminant(parsedDiscriminant, rawDiscriminant) {
     return {
         parsedDiscriminant,
         rawDiscriminant,
     };
 }
+exports.discriminant = discriminant;

package/dist/core/schemas/builders/union/index.d.ts

@@ -1,5 +1,4 @@
-export var __esModule: boolean;
-export var discriminant: typeof discriminant_1.discriminant;
-export var union: typeof union_1.union;
-import discriminant_1 = require("./discriminant");
-import union_1 = require("./union");
+export { discriminant } from "./discriminant";
+export type { Discriminant } from "./discriminant";
+export type { inferParsedDiscriminant, inferParsedUnion, inferRawDiscriminant, inferRawUnion, UnionSubtypes, } from "./types";
+export { union } from "./union";

package/dist/core/schemas/builders/union/types.d.ts

@@ -1 +1,13 @@
-export var __esModule: boolean;
+import { ObjectSchema, inferParsedObject, inferRawObject } from "../object";
+import { Discriminant } from "./discriminant";
+export declare type UnionSubtypes<DiscriminantValues extends string | number | symbol> = {
+    [K in DiscriminantValues]: ObjectSchema<any, any>;
+};
+export declare type inferRawUnion<D extends string | Discriminant<any, any>, U extends UnionSubtypes<keyof U>> = {
+    [K in keyof U]: Record<inferRawDiscriminant<D>, K> & inferRawObject<U[K]>;
+}[keyof U];
+export declare type inferParsedUnion<D extends string | Discriminant<any, any>, U extends UnionSubtypes<keyof U>> = {
+    [K in keyof U]: Record<inferParsedDiscriminant<D>, K> & inferParsedObject<U[K]>;
+}[keyof U];
+export declare type inferRawDiscriminant<D extends string | Discriminant<any, any>> = D extends string ? D : D extends Discriminant<infer Raw, any> ? Raw : never;
+export declare type inferParsedDiscriminant<D extends string | Discriminant<any, any>> = D extends string ? D : D extends Discriminant<any, infer Parsed> ? Parsed : never;

package/dist/core/schemas/builders/union/union.d.ts

@@ -1,8 +1,4 @@
-export var __esModule: boolean;
-export function union(discriminant: any, union: any): {
-    parse: (raw: any, opts: any) => any;
-    json: (parsed: any, opts: any) => any;
-    getType: () => "union";
-} & schema_utils_1.SchemaUtils<any, any> & object_like_1.ObjectLikeUtils<any, any>;
-import schema_utils_1 = require("../schema-utils");
-import object_like_1 = require("../object-like");
+import { ObjectLikeSchema } from "../object-like";
+import { Discriminant } from "./discriminant";
+import { UnionSubtypes, inferParsedUnion, inferRawUnion } from "./types";
+export declare function union<D extends string | Discriminant<any, any>, U extends UnionSubtypes<any>>(discriminant: D, union: U): ObjectLikeSchema<inferRawUnion<D, U>, inferParsedUnion<D, U>>;

package/dist/core/schemas/builders/union/union.js

@@ -1,9 +1,8 @@
 "use strict";
 var __rest = (this && this.__rest) || function (s, e) {
     var t = {};
-    for (var p in s)
-        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-            t[p] = s[p];
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
     if (s != null && typeof Object.getOwnPropertySymbols === "function")
         for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
             if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
@@ -12,7 +11,7 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.union = union;
+exports.union = void 0;
 const Schema_1 = require("../../Schema");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const isPlainObject_1 = require("../../utils/isPlainObject");
@@ -68,6 +67,7 @@ function union(discriminant, union) {
     };
     return Object.assign(Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema)), (0, object_like_1.getObjectLikeUtils)(baseSchema));
 }
+exports.union = union;
 function transformAndValidateUnion({ value, discriminant, transformedDiscriminant, transformDiscriminantValue, getAdditionalPropertiesSchema, allowUnrecognizedUnionMembers = false, transformAdditionalProperties, breadcrumbsPrefix = [], }) {
     if (!(0, isPlainObject_1.isPlainObject)(value)) {
         return {

package/dist/core/schemas/index.d.ts

@@ -1 +1,2 @@
-export var __esModule: boolean;
+export * from "./builders";
+export type { inferParsed, inferRaw, Schema, SchemaOptions } from "./Schema";

package/dist/core/schemas/index.js

@@ -1,21 +1,17 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function (o, m, k, k2) {
-    if (k2 === undefined)
-        k2 = k;
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
     if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function () { return m[k]; } };
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
     Object.defineProperty(o, k2, desc);
-}) : (function (o, m, k, k2) {
-    if (k2 === undefined)
-        k2 = k;
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
-var __exportStar = (this && this.__exportStar) || function (m, exports) {
-    for (var p in m)
-        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p))
-            __createBinding(exports, m, p);
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./builders"), exports);

package/dist/core/schemas/utils/MaybePromise.d.ts

@@ -1 +1 @@
-export var __esModule: boolean;
+export declare type MaybePromise<T> = T | Promise<T>;

package/dist/core/schemas/utils/addQuestionMarksToNullableProperties.d.ts

@@ -1 +1,7 @@
-export var __esModule: boolean;
+export declare type addQuestionMarksToNullableProperties<T> = {
+    [K in OptionalKeys<T>]?: T[K];
+} & Pick<T, RequiredKeys<T>>;
+export declare type OptionalKeys<T> = {
+    [K in keyof T]-?: undefined extends T[K] ? K : never;
+}[keyof T];
+export declare type RequiredKeys<T> = Exclude<keyof T, OptionalKeys<T>>;

package/dist/core/schemas/utils/createIdentitySchemaCreator.d.ts

@@ -1,7 +1,2 @@
-export var __esModule: boolean;
-export function createIdentitySchemaCreator(schemaType: any, validate: any): () => {
-    parse: any;
-    json: any;
-    getType: () => any;
-} & schema_utils_1.SchemaUtils<any, any>;
-import schema_utils_1 = require("../builders/schema-utils");
+import { MaybeValid, Schema, SchemaOptions, SchemaType } from "../Schema";
+export declare function createIdentitySchemaCreator<T>(schemaType: SchemaType, validate: (value: unknown, opts?: SchemaOptions) => MaybeValid<T>): () => Schema<T, T>;

package/dist/core/schemas/utils/createIdentitySchemaCreator.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createIdentitySchemaCreator = createIdentitySchemaCreator;
+exports.createIdentitySchemaCreator = void 0;
 const schema_utils_1 = require("../builders/schema-utils");
 const maybeSkipValidation_1 = require("./maybeSkipValidation");
 function createIdentitySchemaCreator(schemaType, validate) {
@@ -13,3 +13,4 @@ function createIdentitySchemaCreator(schemaType, validate) {
         return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
     };
 }
+exports.createIdentitySchemaCreator = createIdentitySchemaCreator;

package/dist/core/schemas/utils/entries.d.ts

@@ -1,2 +1 @@
-export var __esModule: boolean;
-export function entries(object: any): [string, any][];
+export declare function entries<T extends object>(object: T): [keyof T, T[keyof T]][];

package/dist/core/schemas/utils/entries.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.entries = entries;
+exports.entries = void 0;
 function entries(object) {
     return Object.entries(object);
 }
+exports.entries = entries;

package/dist/core/schemas/utils/filterObject.d.ts

@@ -1,2 +1 @@
-export var __esModule: boolean;
-export function filterObject(obj: any, keysToInclude: any): {};
+export declare function filterObject<T extends object, K extends keyof T>(obj: T, keysToInclude: K[]): Pick<T, K>;

package/dist/core/schemas/utils/filterObject.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.filterObject = filterObject;
+exports.filterObject = void 0;
 function filterObject(obj, keysToInclude) {
     const keysToIncludeSet = new Set(keysToInclude);
     return Object.entries(obj).reduce((acc, [key, value]) => {
@@ -11,3 +11,4 @@ function filterObject(obj, keysToInclude) {
         // eslint-disable-next-line @typescript-eslint/prefer-reduce-type-parameter
     }, {});
 }
+exports.filterObject = filterObject;

package/dist/core/schemas/utils/getErrorMessageForIncorrectType.d.ts

@@ -1,2 +1 @@
-export var __esModule: boolean;
-export function getErrorMessageForIncorrectType(value: any, expectedType: any): string;
+export declare function getErrorMessageForIncorrectType(value: unknown, expectedType: string): string;

package/dist/core/schemas/utils/getErrorMessageForIncorrectType.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getErrorMessageForIncorrectType = getErrorMessageForIncorrectType;
+exports.getErrorMessageForIncorrectType = void 0;
 function getErrorMessageForIncorrectType(value, expectedType) {
     return `Expected ${expectedType}. Received ${getTypeAsString(value)}.`;
 }
+exports.getErrorMessageForIncorrectType = getErrorMessageForIncorrectType;
 function getTypeAsString(value) {
     if (Array.isArray(value)) {
         return "list";

package/dist/core/schemas/utils/isPlainObject.d.ts

@@ -1,2 +1 @@
-export var __esModule: boolean;
-export function isPlainObject(value: any): boolean;
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;

package/dist/core/schemas/utils/isPlainObject.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPlainObject = isPlainObject;
+exports.isPlainObject = void 0;
 // borrowed from https://github.com/lodash/lodash/blob/master/isPlainObject.js
 function isPlainObject(value) {
     if (typeof value !== "object" || value === null) {
@@ -15,3 +15,4 @@ function isPlainObject(value) {
     }
     return Object.getPrototypeOf(value) === proto;
 }
+exports.isPlainObject = isPlainObject;

package/dist/core/schemas/utils/keys.d.ts

@@ -1,2 +1 @@
-export var __esModule: boolean;
-export function keys(object: any): string[];
+export declare function keys<T extends object>(object: T): (keyof T)[];

package/dist/core/schemas/utils/keys.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.keys = keys;
+exports.keys = void 0;
 function keys(object) {
     return Object.keys(object);
 }
+exports.keys = keys;

package/dist/core/schemas/utils/maybeSkipValidation.d.ts

@@ -1,2 +1,2 @@
-export var __esModule: boolean;
-export function maybeSkipValidation(schema: any): any;
+import { BaseSchema } from "../Schema";
+export declare function maybeSkipValidation<S extends BaseSchema<Raw, Parsed>, Raw, Parsed>(schema: S): S;

package/dist/core/schemas/utils/maybeSkipValidation.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.maybeSkipValidation = maybeSkipValidation;
+exports.maybeSkipValidation = void 0;
 function maybeSkipValidation(schema) {
     return Object.assign(Object.assign({}, schema), { json: transformAndMaybeSkipValidation(schema.json), parse: transformAndMaybeSkipValidation(schema.parse) });
 }
+exports.maybeSkipValidation = maybeSkipValidation;
 function transformAndMaybeSkipValidation(transform) {
     return (value, opts) => {
         const transformed = transform(value, opts);

package/dist/core/schemas/utils/partition.d.ts

@@ -1,2 +1 @@
-export var __esModule: boolean;
-export function partition(items: any, predicate: any): any[][];
+export declare function partition<T>(items: readonly T[], predicate: (item: T) => boolean): [T[], T[]];

package/dist/core/schemas/utils/partition.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.partition = partition;
+exports.partition = void 0;
 function partition(items, predicate) {
     const trueItems = [], falseItems = [];
     for (const item of items) {
@@ -13,3 +13,4 @@ function partition(items, predicate) {
     }
     return [trueItems, falseItems];
 }
+exports.partition = partition;

package/dist/errors/RulebricksApiError.d.ts

@@ -1,10 +1,12 @@
-export var __esModule: boolean;
-export class RulebricksApiError extends Error {
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+export declare class RulebricksApiError extends Error {
+    readonly statusCode?: number;
+    readonly body?: unknown;
     constructor({ message, statusCode, body }: {
-        message: any;
-        statusCode: any;
-        body: any;
+        message?: string;
+        statusCode?: number;
+        body?: unknown;
     });
-    statusCode: any;
-    body: any;
 }

package/dist/errors/RulebricksApiTimeoutError.d.ts

@@ -1,4 +1,6 @@
-export var __esModule: boolean;
-export class RulebricksApiTimeoutError extends Error {
-    constructor(message: any);
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+export declare class RulebricksApiTimeoutError extends Error {
+    constructor(message: string);
 }

package/dist/errors/index.d.ts

@@ -1,5 +1,2 @@
-export var __esModule: boolean;
-export var RulebricksApiError: typeof RulebricksApiError_1.RulebricksApiError;
-export var RulebricksApiTimeoutError: typeof RulebricksApiTimeoutError_1.RulebricksApiTimeoutError;
-import RulebricksApiError_1 = require("./RulebricksApiError");
-import RulebricksApiTimeoutError_1 = require("./RulebricksApiTimeoutError");
+export { RulebricksApiError } from "./RulebricksApiError";
+export { RulebricksApiTimeoutError } from "./RulebricksApiTimeoutError";

package/dist/forge/index.d.ts

@@ -0,0 +1,4 @@
+export { Rule, Condition, RuleTest } from "./rule";
+export { DynamicValue, DynamicValues } from "./values";
+export { BooleanField, NumberField, StringField, DateField, ListField } from "./operators";
+export * from "./types";

package/dist/forge/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListField = exports.DateField = exports.StringField = exports.NumberField = exports.BooleanField = exports.DynamicValues = exports.DynamicValue = exports.RuleTest = exports.Condition = exports.Rule = void 0;
+var rule_1 = require("./rule");
+Object.defineProperty(exports, "Rule", { enumerable: true, get: function () { return rule_1.Rule; } });
+Object.defineProperty(exports, "Condition", { enumerable: true, get: function () { return rule_1.Condition; } });
+Object.defineProperty(exports, "RuleTest", { enumerable: true, get: function () { return rule_1.RuleTest; } });
+var values_1 = require("./values");
+Object.defineProperty(exports, "DynamicValue", { enumerable: true, get: function () { return values_1.DynamicValue; } });
+Object.defineProperty(exports, "DynamicValues", { enumerable: true, get: function () { return values_1.DynamicValues; } });
+var operators_1 = require("./operators");
+Object.defineProperty(exports, "BooleanField", { enumerable: true, get: function () { return operators_1.BooleanField; } });
+Object.defineProperty(exports, "NumberField", { enumerable: true, get: function () { return operators_1.NumberField; } });
+Object.defineProperty(exports, "StringField", { enumerable: true, get: function () { return operators_1.StringField; } });
+Object.defineProperty(exports, "DateField", { enumerable: true, get: function () { return operators_1.DateField; } });
+Object.defineProperty(exports, "ListField", { enumerable: true, get: function () { return operators_1.ListField; } });
+__exportStar(require("./types"), exports);

package/dist/forge/operators.d.ts

@@ -0,0 +1,136 @@
+import { Field, RuleType, OperatorDef, DynamicValueType } from "./types.js";
+import { DynamicValue } from "./values.js";
+export declare type OperatorResult = [string, any[]];
+export declare class Argument<T> {
+    private value;
+    private expectedType;
+    constructor(value: T | DynamicValue, expectedType: DynamicValueType);
+    private validateType;
+    private getExpectedJsType;
+    toDict(): any;
+    static process(arg: any, expectedType: DynamicValueType): any;
+    toString(): string;
+}
+export declare class BooleanField implements Field {
+    readonly type = RuleType.BOOLEAN;
+    readonly operators: Record<string, OperatorDef>;
+    readonly defaultValue: boolean;
+    readonly name: string;
+    readonly description: string;
+    constructor(name: string, description?: string, defaultValue?: boolean);
+    equals(value: boolean | DynamicValue): OperatorResult;
+}
+export declare class NumberField implements Field {
+    readonly type = RuleType.NUMBER;
+    readonly operators: Record<string, OperatorDef>;
+    readonly defaultValue: number;
+    readonly name: string;
+    readonly description: string;
+    constructor(name: string, description?: string, defaultValue?: number);
+    equals(value: number | DynamicValue): OperatorResult;
+    not_equals(value: number | DynamicValue): OperatorResult;
+    greater_than(value: number | DynamicValue): OperatorResult;
+    less_than(value: number | DynamicValue): OperatorResult;
+    greater_than_or_equal(value: number | DynamicValue): OperatorResult;
+    less_than_or_equal(value: number | DynamicValue): OperatorResult;
+    between(start: number | DynamicValue, end: number | DynamicValue): OperatorResult;
+    not_between(start: number | DynamicValue, end: number | DynamicValue): OperatorResult;
+    is_even(): OperatorResult;
+    is_odd(): OperatorResult;
+    is_positive(): OperatorResult;
+    is_negative(): OperatorResult;
+    is_zero(): OperatorResult;
+    is_not_zero(): OperatorResult;
+    is_multiple_of(value: number | DynamicValue): OperatorResult;
+    is_not_multiple_of(value: number | DynamicValue): OperatorResult;
+    is_power_of(base: number | DynamicValue): OperatorResult;
+}
+export declare class DateField implements Field {
+    readonly type = RuleType.DATE;
+    readonly operators: Record<string, OperatorDef>;
+    readonly defaultValue: Date;
+    readonly name: string;
+    readonly description: string;
+    constructor(name: string, description?: string, defaultValue?: Date | null);
+    is_past(): OperatorResult;
+    is_future(): OperatorResult;
+    days_ago(days: number | DynamicValue): OperatorResult;
+    less_than_days_ago(days: number | DynamicValue): OperatorResult;
+    more_than_days_ago(days: number | DynamicValue): OperatorResult;
+    days_from_now(days: number | DynamicValue): OperatorResult;
+    less_than_days_from_now(days: number | DynamicValue): OperatorResult;
+    more_than_days_from_now(days: number | DynamicValue): OperatorResult;
+    is_today(): OperatorResult;
+    is_this_week(): OperatorResult;
+    is_this_month(): OperatorResult;
+    is_this_year(): OperatorResult;
+    is_next_week(): OperatorResult;
+    is_next_month(): OperatorResult;
+    is_next_year(): OperatorResult;
+    is_last_week(): OperatorResult;
+    is_last_month(): OperatorResult;
+    is_last_year(): OperatorResult;
+    after(date: Date | string | DynamicValue): OperatorResult;
+    on_or_after(date: Date | string | DynamicValue): OperatorResult;
+    before(date: Date | string | DynamicValue): OperatorResult;
+    on_or_before(date: Date | string | DynamicValue): OperatorResult;
+    between(start: Date | string | DynamicValue, end: Date | string | DynamicValue): OperatorResult;
+}
+export declare class StringField implements Field {
+    readonly type = RuleType.STRING;
+    readonly operators: Record<string, OperatorDef>;
+    readonly defaultValue: string;
+    readonly name: string;
+    readonly description: string;
+    constructor(name: string, description?: string, defaultValue?: string);
+    contains(value: string | DynamicValue): OperatorResult;
+    not_contains(value: string | DynamicValue): OperatorResult;
+    equals(value: string | DynamicValue): OperatorResult;
+    not_equals(value: string | DynamicValue): OperatorResult;
+    is_empty(): OperatorResult;
+    is_not_empty(): OperatorResult;
+    starts_with(value: string | DynamicValue): OperatorResult;
+    ends_with(value: string | DynamicValue): OperatorResult;
+    is_included_in(values: string[] | DynamicValue): OperatorResult;
+    matches_regex(pattern: string | DynamicValue): OperatorResult;
+    not_matches_regex(pattern: string | DynamicValue): OperatorResult;
+    is_email(): OperatorResult;
+    is_not_email(): OperatorResult;
+    is_url(): OperatorResult;
+    is_not_url(): OperatorResult;
+    is_ip(): OperatorResult;
+    is_not_ip(): OperatorResult;
+    is_uppercase(): OperatorResult;
+    is_lowercase(): OperatorResult;
+    is_numeric(): OperatorResult;
+    contains_only_digits(): OperatorResult;
+    contains_only_letters(): OperatorResult;
+    contains_only_digits_and_letters(): OperatorResult;
+}
+export declare class ListField implements Field {
+    readonly type = RuleType.LIST;
+    readonly operators: Record<string, OperatorDef>;
+    readonly defaultValue: any[];
+    readonly name: string;
+    readonly description: string;
+    constructor(name: string, description?: string, defaultValue?: any[]);
+    contains(value: any | DynamicValue): OperatorResult;
+    is_empty(): OperatorResult;
+    is_not_empty(): OperatorResult;
+    length_equals(length: number | DynamicValue): OperatorResult;
+    length_not_equals(length: number | DynamicValue): OperatorResult;
+    longer_than(length: number | DynamicValue): OperatorResult;
+    shorter_than(length: number | DynamicValue): OperatorResult;
+    contains_all(values: any[] | DynamicValue): OperatorResult;
+    contains_any(values: any[] | DynamicValue): OperatorResult;
+    contains_none(values: any[] | DynamicValue): OperatorResult;
+    not_contains(value: any | DynamicValue): OperatorResult;
+    equals(other: any[] | DynamicValue): OperatorResult;
+    not_equals(other: any[] | DynamicValue): OperatorResult;
+    has_duplicates(): OperatorResult;
+    no_duplicates(): OperatorResult;
+    contains_object_with_key_value(key: string | DynamicValue, value: any | DynamicValue): OperatorResult;
+    has_unique_elements(): OperatorResult;
+    is_sublist_of(superlist: any[] | DynamicValue): OperatorResult;
+    is_superlist_of(sublist: any[] | DynamicValue): OperatorResult;
+}