@cleverbrush/schema 1.0.0-beta.5 → 1.0.0

package/dist/builders/UnionSchemaBuilder.d.ts

@@ -1,10 +1,130 @@
-import { ISchemaBuilder } from './SchemaBuilder.js';
-export interface IUnionSchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false, TVariants extends any[] = []> extends ISchemaBuilder<TRequired, TNullable> {
-    optional(): IUnionSchemaBuilder<false, TNullable, TVariants>;
-    required(): IUnionSchemaBuilder<true, TNullable, TVariants>;
-    nullable(): IUnionSchemaBuilder<TRequired, true, TVariants>;
-    notNullable(): IUnionSchemaBuilder<TRequired, false, TVariants>;
-    or<T>(schema: T): IUnionSchemaBuilder<TRequired, TNullable, [...TVariants, T]>;
-    clearVariants(): IUnionSchemaBuilder<TRequired, TNullable, []>;
+import { SchemaBuilder, ValidationResult, ValidationContext, InferType } from './SchemaBuilder.js';
+type UnionSchemaBuilderCreateProps<T extends readonly SchemaBuilder<any, any>[], R extends boolean = true> = Partial<ReturnType<UnionSchemaBuilder<T, R>['introspect']>>;
+type SchemaArrayToUnion<TArr extends readonly any[]> = TArr['length'] extends 1 ? InferType<TArr[0]> : TArr extends readonly [infer TFirst, ...infer TRest] ? InferType<TFirst> | SchemaArrayToUnion<[...TRest]> : never;
+type TakeBeforeIndex<TArr extends readonly SchemaBuilder<any, any>[], TIndex extends number> = TArr extends [
+    ...infer TRest extends SchemaBuilder<any, any>[],
+    infer TLast extends SchemaBuilder<any, any>
+] ? TRest['length'] extends TIndex ? TRest : TakeBeforeIndex<TRest, TIndex> : never;
+type TakeAfterIndex<TArr extends readonly SchemaBuilder<any, any>[], TIndex extends number, TAcc extends readonly SchemaBuilder<any, any>[] = []> = TArr extends [
+    ...infer TRest extends SchemaBuilder<any, any>[],
+    infer TLast extends SchemaBuilder<any, any>
+] ? TRest['length'] extends TIndex ? TAcc : TakeAfterIndex<TRest, TIndex, [TLast, ...TAcc]> : never;
+type TakeExceptIndex<TArr extends readonly SchemaBuilder<any, any>[], TIndex extends number> = [...TakeBeforeIndex<TArr, TIndex>, ...TakeAfterIndex<TArr, TIndex>];
+/**
+ * Union schema builder class. Allows to create schemas
+ * containing alternatives. E.g. string | number | Date.
+ * Use it when you want to define a schema for a value
+ * that can be of different types. The type of the value
+ * will be determined by the first schema that succeeds
+ * validation. Any schema type can be supplied as variant.
+ * Which means that you are not limited to primitive types and
+ * can construct complex types as well, e.g. object | array.
+ *
+ * **NOTE** this class is exported only to give opportunity to extend it
+ * by inheriting. It is not recommended to create an instance of this class
+ * directly. Use {@link union | union()} function instead.
+ *
+ * @example
+ * ```ts
+ * const schema = union(string('foo')).or(string('bar'));
+ * const result = await schema.validate('foo');
+ * // result.valid === true
+ * // result.object === 'foo'
+ * ```
+ *
+ * @example
+ * ```ts
+ * const schema = union(string('foo')).or(string('bar'));
+ * const result = await schema.validate('baz');
+ * // result.valid === false
+ * ```
+ *
+ * @example
+ * ```ts
+ * const schema = union(string('yes')).or(string('no')).or(number(0)).or(number(1));
+ * // equals to 'yes' | 'no' | 0 | 1 in TS
+ * const result = await schema.validate('yes');
+ * // result.valid === true
+ * // result.object === 'yes'
+ *
+ * const result2 = await schema.validate(0);
+ * // result2.valid === true
+ * // result2.object === 0
+ *
+ * const result3 = await schema.validate('baz');
+ * // result3.valid === false
+ *
+ * const result4 = await schema.validate(2);
+ * // result4.valid === false
+ * ```
+ *
+ * @see {@link union}
+ */
+export declare class UnionSchemaBuilder<TOptions extends readonly SchemaBuilder<any, any>[], TRequired extends boolean = true, TExplicitType = undefined, TResult = TExplicitType extends undefined ? SchemaArrayToUnion<TOptions> : TExplicitType> extends SchemaBuilder<TResult, TRequired> {
+    #private;
+    static create(props: UnionSchemaBuilderCreateProps<any>): UnionSchemaBuilder<any, true, undefined, any>;
+    private constructor();
+    introspect(): {
+        /**
+         * Array of schemas participating in the union.
+         */
+        options: TOptions;
+        type: string;
+        isRequired: boolean;
+        preprocessors: readonly import("./SchemaBuilder.js").Preprocessor<TResult>[];
+        validators: readonly import("./SchemaBuilder.js").Validator<TResult>[];
+    };
+    /**
+     * @hidden
+     */
+    hasType<T>(notUsed?: T): UnionSchemaBuilder<TOptions, true, T>;
+    /**
+     * @hidden
+     */
+    clearHasType(): UnionSchemaBuilder<TOptions, TRequired, undefined>;
+    /**
+     * Performs validion of the union schema over `object`.
+     * @param context Optional `ValidationContext` settings.
+     */
+    validate(object: TResult, context?: ValidationContext): Promise<ValidationResult<TResult>>;
+    protected createFromProps<T extends readonly SchemaBuilder<any, any>[], TReq extends boolean>(props: UnionSchemaBuilderCreateProps<T, TReq>): this;
+    /**
+     * @hidden
+     */
+    required(): UnionSchemaBuilder<TOptions, true, TExplicitType>;
+    /**
+     * @hidden
+     */
+    optional(): UnionSchemaBuilder<TOptions, false, TExplicitType>;
+    /**
+     * Adds a new schema option described by `schema`.
+     * schema must be an instance of `SchemaBuilder` class ancestor.
+     * @param schema schema to be added as an option.
+     */
+    or<T extends SchemaBuilder<any, any>>(schema: T): UnionSchemaBuilder<[...TOptions, T], TRequired, TExplicitType>;
+    /**
+     * Removes option by its `index`. If `index` is out of bounds,
+     * an error is thrown.
+     * @param index index of the option, starting from `0`.
+     */
+    removeOption<T extends number>(index: T): UnionSchemaBuilder<TakeExceptIndex<TOptions, T>, TRequired, TExplicitType>;
+    /**
+     * Removes first option from the union schema.
+     */
+    removeFirstOption(): TOptions extends [
+        infer TFirst,
+        ...infer TRest extends SchemaBuilder<any, any>[]
+    ] ? UnionSchemaBuilder<TRest, TRequired, TExplicitType> : never;
+    /**
+     * Removes all options and replaces them by single `schema` option.
+     * Equivalent to `union(schema)` function, but could be useful in some cases.
+     * @param schema schema to be added as a single option to the new schema.
+     */
+    reset<T extends SchemaBuilder<any, any>>(schema: T): UnionSchemaBuilder<[T], TRequired, TExplicitType>;
 }
-export declare const union: <T extends ISchemaBuilder<true, false>, K extends T[], TRequired extends boolean = true, TNullable extends boolean = false>(...schemas: K) => IUnionSchemaBuilder<TRequired, TNullable, K>;
+/**
+ * Creates a union schema.
+ * @param schema required and will be considered as a first option for the union shchema.
+ */
+export declare const union: <T extends SchemaBuilder<any, any>>(schema: T) => UnionSchemaBuilder<[T], true, undefined, InferType<T>>;
+export {};

package/dist/builders/UnionSchemaBuilder.js

@@ -1,95 +1,216 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.union = void 0;
-const SchemaBuilder_js_1 = require("./SchemaBuilder.js");
-class UnionSchemaBuilder extends SchemaBuilder_js_1.SchemaBuilder {
-    type = 'union';
-    get _schema() {
-        return Object.assign({
-            type: this.type
-        }, this.getCommonSchema(), {
-            variants: this._variants
+import { SchemaBuilder } from './SchemaBuilder.js';
+/**
+ * Union schema builder class. Allows to create schemas
+ * containing alternatives. E.g. string | number | Date.
+ * Use it when you want to define a schema for a value
+ * that can be of different types. The type of the value
+ * will be determined by the first schema that succeeds
+ * validation. Any schema type can be supplied as variant.
+ * Which means that you are not limited to primitive types and
+ * can construct complex types as well, e.g. object | array.
+ *
+ * **NOTE** this class is exported only to give opportunity to extend it
+ * by inheriting. It is not recommended to create an instance of this class
+ * directly. Use {@link union | union()} function instead.
+ *
+ * @example
+ * ```ts
+ * const schema = union(string('foo')).or(string('bar'));
+ * const result = await schema.validate('foo');
+ * // result.valid === true
+ * // result.object === 'foo'
+ * ```
+ *
+ * @example
+ * ```ts
+ * const schema = union(string('foo')).or(string('bar'));
+ * const result = await schema.validate('baz');
+ * // result.valid === false
+ * ```
+ *
+ * @example
+ * ```ts
+ * const schema = union(string('yes')).or(string('no')).or(number(0)).or(number(1));
+ * // equals to 'yes' | 'no' | 0 | 1 in TS
+ * const result = await schema.validate('yes');
+ * // result.valid === true
+ * // result.object === 'yes'
+ *
+ * const result2 = await schema.validate(0);
+ * // result2.valid === true
+ * // result2.object === 0
+ *
+ * const result3 = await schema.validate('baz');
+ * // result3.valid === false
+ *
+ * const result4 = await schema.validate(2);
+ * // result4.valid === false
+ * ```
+ *
+ * @see {@link union}
+ */
+export class UnionSchemaBuilder extends SchemaBuilder {
+    #options;
+    static create(props) {
+        return new UnionSchemaBuilder({
+            type: 'union',
+            ...props
         });
     }
-    clone() {
-        return UnionSchemaBuilder.create(this._schema);
+    constructor(props) {
+        super(props);
+        if (Array.isArray(props.options)) {
+            this.#options = props.options;
+        }
+    }
+    introspect() {
+        return {
+            ...super.introspect(),
+            /**
+             * Array of schemas participating in the union.
+             */
+            options: this.#options
+        };
+    }
+    /**
+     * @hidden
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    hasType(notUsed) {
+        return this.createFromProps({
+            ...this.introspect()
+        });
     }
-    _variants;
-    static create(obj) {
-        return new UnionSchemaBuilder(obj);
+    /**
+     * @hidden
+     */
+    clearHasType() {
+        return this.createFromProps({
+            ...this.introspect()
+        });
     }
-    constructor(obj) {
-        super(obj);
-        this._variants = [];
-        if (Array.isArray(obj.variants)) {
-            for (let i = 0; i < obj.variants.length; i++) {
-                this._variants.push(obj.variants[i]);
+    /**
+     * Performs validion of the union schema over `object`.
+     * @param context Optional `ValidationContext` settings.
+     */
+    async validate(object, context) {
+        const superResult = await super.preValidate(object, context);
+        const { valid, transaction: preValidationTransaction, context: prevalidationContext, errors } = superResult;
+        const { path } = prevalidationContext;
+        if (!valid) {
+            return {
+                valid,
+                errors
+            };
+        }
+        let { object: { validatedObject: objToValidate } } = preValidationTransaction;
+        if (!this.isRequired &&
+            (typeof objToValidate === 'undefined' || objToValidate === null)) {
+            return {
+                valid: true,
+                object: objToValidate
+            };
+        }
+        let minErrorsCount = Number.MAX_SAFE_INTEGER;
+        let resultingErrors = [];
+        for (let i = 0; i < this.#options.length; i++) {
+            const { valid, errors, object: validatedOption } = await this.#options[i].validate(objToValidate, {
+                ...prevalidationContext,
+                path: `${path}[option ${i}]`
+            });
+            if (valid) {
+                return {
+                    valid: true,
+                    object: validatedOption
+                };
+            }
+            else {
+                if (Array.isArray(errors) &&
+                    errors.length > 0 &&
+                    errors.length < minErrorsCount) {
+                    resultingErrors = errors;
+                    minErrorsCount = errors.length;
+                }
+                objToValidate =
+                    preValidationTransaction.rollback().validatedObject;
             }
         }
+        return {
+            valid: false,
+            errors: resultingErrors
+        };
     }
-    optional() {
-        if (this.isRequired === false) {
-            return this;
-        }
-        return UnionSchemaBuilder.create({
-            ...this._schema,
-            isRequired: false
-        });
+    createFromProps(props) {
+        return UnionSchemaBuilder.create(props);
     }
+    /**
+     * @hidden
+     */
     required() {
-        if (this.isRequired === true) {
-            return this;
-        }
-        return UnionSchemaBuilder.create({
-            ...this._schema,
-            isRequired: true
-        });
+        return super.required();
     }
-    nullable() {
-        if (this.isNullable === true) {
-            return this;
+    /**
+     * @hidden
+     */
+    optional() {
+        return super.optional();
+    }
+    /**
+     * Adds a new schema option described by `schema`.
+     * schema must be an instance of `SchemaBuilder` class ancestor.
+     * @param schema schema to be added as an option.
+     */
+    or(schema) {
+        if (!(schema instanceof SchemaBuilder)) {
+            throw new Error('schema must be an instance of the SchemaBuilder class');
         }
-        return UnionSchemaBuilder.create({
-            ...this._schema,
-            isNullable: true
+        return this.createFromProps({
+            ...this.introspect(),
+            options: [...this.#options, schema]
         });
     }
-    notNullable() {
-        if (this.isNullable === false) {
-            return this;
+    /**
+     * Removes option by its `index`. If `index` is out of bounds,
+     * an error is thrown.
+     * @param index index of the option, starting from `0`.
+     */
+    removeOption(index) {
+        if (typeof index !== 'number' ||
+            index < 0 ||
+            index > this.#options.length) {
+            throw new Error('index must be >= 0 and <= count of the options');
         }
-        return UnionSchemaBuilder.create({
-            ...this._schema,
-            isNullable: false
+        return this.createFromProps({
+            ...this.introspect(),
+            options: this.#options.filter((v, i) => i !== index)
         });
     }
-    or(schema) {
-        return UnionSchemaBuilder.create({
-            ...this._schema,
-            variants: [...this._variants, schema]
-        });
+    /**
+     * Removes first option from the union schema.
+     */
+    removeFirstOption() {
+        return this.removeOption(0);
     }
-    clearVariants() {
-        if (this._variants.length === 0)
-            return this;
-        return UnionSchemaBuilder.create({
-            ...this._schema,
-            variants: []
+    /**
+     * Removes all options and replaces them by single `schema` option.
+     * Equivalent to `union(schema)` function, but could be useful in some cases.
+     * @param schema schema to be added as a single option to the new schema.
+     */
+    reset(schema) {
+        if (!(schema instanceof SchemaBuilder)) {
+            throw new Error('schema must be an instance of the SchemaBuilder class');
+        }
+        return this.createFromProps({
+            ...this.introspect(),
+            options: [schema]
         });
     }
 }
-const union = (...schemas) => {
-    if (schemas.length < 1) {
-        throw new Error('should provide at least one variant');
-    }
-    let res = UnionSchemaBuilder.create({
-        isRequired: true,
-        isNullable: false,
-        variants: [schemas[0]]
-    });
-    for (let i = 1; i < schemas.length; i++) {
-        res = res.or(schemas[i]);
-    }
-    return res;
-};
-exports.union = union;
+/**
+ * Creates a union schema.
+ * @param schema required and will be considered as a first option for the union shchema.
+ */
+export const union = (schema) => UnionSchemaBuilder.create({
+    isRequired: true,
+    options: [schema]
+});

package/dist/index.d.ts

@@ -1,40 +1,20 @@
-import { InferType, ExpandSchemaBuilder, ValidationResultWithObject } from './schema.js';
-import SchemaRegistry from './schemaRegistry.js';
-import { array } from './builders/ArraySchemaBuilder.js';
-import { boolean } from './builders/BooleanSchemaBuilder.js';
-import { number } from './builders/NumberSchemaBuilder.js';
-import { object } from './builders/ObjectSchemaBuilder.js';
-import { string } from './builders/StringSchemaBuilder.js';
-import { union } from './builders/UnionSchemaBuilder.js';
-import { func } from './builders/FunctionSchemaBuilder.js';
-export declare type GetNodes<T extends Record<string, any>, TPrefix extends string = ''> = {
-    [k in keyof T]: k extends `${TPrefix}${infer F}.${infer S}` ? F : never;
-}[keyof T];
-export declare type GetLeafs<T extends Record<string, any>, TPrefix extends string = ''> = {
-    [k in keyof T]: k extends `${TPrefix}${infer F}` ? F extends `${infer S}.${infer G}` ? never : F : never;
-}[keyof T];
-export declare type Unfold<TBag extends Record<string, any>, TPrefix extends string = ''> = {
-    [k in GetLeafs<TBag, TPrefix>]: ISchemaActions<TBag[`${TPrefix}${k}`]>;
-} & {
-    [k in GetNodes<TBag, TPrefix>]: Unfold<TBag, `${TPrefix}${k}.`>;
-};
-export interface ISchemaActions<S> {
-    validate(value: any): Promise<ValidationResultWithObject<InferType<ExpandSchemaBuilder<S>>>>;
-    schema: ExpandSchemaBuilder<S>;
-}
-export interface ISchemaRegistry<T extends Record<string, any>> {
-    schemas: Unfold<T>;
-}
-export { SchemaRegistry };
-declare const _default: {
-    SchemaRegistry: typeof SchemaRegistry;
-    array: () => import("./builders/ArraySchemaBuilder.js").IArraySchemaBuilder<true, false, undefined, undefined, undefined>;
-    boolean: () => import("./builders/BooleanSchemaBuilder.js").IBooleanSchemaBuilder<true, false, undefined>;
-    number: () => import("./builders/NumberSchemaBuilder.js").INumberSchemaBuilder<true, false, undefined, undefined, undefined, true, true, undefined>;
-    object: <T>(properties?: T) => import("./builders/ObjectSchemaBuilder.js").IObjectSchemaBuilder<true, false, true, T extends undefined ? {} : T, undefined>;
-    string: <T_1 extends string = undefined>(equals?: T_1) => import("./builders/StringSchemaBuilder.js").IStringSchemaBuilder<true, false, undefined, undefined, T_1 extends undefined ? undefined : T_1>;
-    union: <T_2 extends import("./builders/SchemaBuilder.js").ISchemaBuilder<true, false>, K extends T_2[], TRequired extends boolean = true, TNullable extends boolean = false>(...schemas: K) => import("./builders/UnionSchemaBuilder.js").IUnionSchemaBuilder<TRequired, TNullable, K>;
-    func: () => import("./builders/FunctionSchemaBuilder.js").IFunctionSchemaBuilder<true, false, undefined>;
-};
-export default _default;
-export { array, boolean, number, object, string, union, func, InferType };
+export { AnySchemaBuilder } from './builders/AnySchemaBuilder.js';
+export { ArraySchemaBuilder } from './builders/ArraySchemaBuilder.js';
+export { BooleanSchemaBuilder } from './builders/BooleanSchemaBuilder.js';
+export { DateSchemaBuilder } from './builders/DateSchemaBuilder.js';
+export { FunctionSchemaBuilder } from './builders/FunctionSchemaBuilder.js';
+export { ObjectSchemaBuilder } from './builders/ObjectSchemaBuilder.js';
+export { NumberSchemaBuilder } from './builders/NumberSchemaBuilder.js';
+export { StringSchemaBuilder } from './builders/StringSchemaBuilder.js';
+export { UnionSchemaBuilder } from './builders/UnionSchemaBuilder.js';
+export { SchemaBuilder } from './builders/SchemaBuilder.js';
+export { InferType, MakeOptional, MakeRequired, ValidationError, ValidationResult } from './builders/SchemaBuilder.js';
+export { any } from './builders/AnySchemaBuilder.js';
+export { array } from './builders/ArraySchemaBuilder.js';
+export { boolean } from './builders/BooleanSchemaBuilder.js';
+export { date } from './builders/DateSchemaBuilder.js';
+export { func } from './builders/FunctionSchemaBuilder.js';
+export { number } from './builders/NumberSchemaBuilder.js';
+export { object } from './builders/ObjectSchemaBuilder.js';
+export { string } from './builders/StringSchemaBuilder.js';
+export { union } from './builders/UnionSchemaBuilder.js';

package/dist/index.js

@@ -1,32 +1,19 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.func = exports.union = exports.string = exports.object = exports.number = exports.boolean = exports.array = exports.SchemaRegistry = void 0;
-const schemaRegistry_js_1 = __importDefault(require("./schemaRegistry.js"));
-exports.SchemaRegistry = schemaRegistry_js_1.default;
-const ArraySchemaBuilder_js_1 = require("./builders/ArraySchemaBuilder.js");
-Object.defineProperty(exports, "array", { enumerable: true, get: function () { return ArraySchemaBuilder_js_1.array; } });
-const BooleanSchemaBuilder_js_1 = require("./builders/BooleanSchemaBuilder.js");
-Object.defineProperty(exports, "boolean", { enumerable: true, get: function () { return BooleanSchemaBuilder_js_1.boolean; } });
-const NumberSchemaBuilder_js_1 = require("./builders/NumberSchemaBuilder.js");
-Object.defineProperty(exports, "number", { enumerable: true, get: function () { return NumberSchemaBuilder_js_1.number; } });
-const ObjectSchemaBuilder_js_1 = require("./builders/ObjectSchemaBuilder.js");
-Object.defineProperty(exports, "object", { enumerable: true, get: function () { return ObjectSchemaBuilder_js_1.object; } });
-const StringSchemaBuilder_js_1 = require("./builders/StringSchemaBuilder.js");
-Object.defineProperty(exports, "string", { enumerable: true, get: function () { return StringSchemaBuilder_js_1.string; } });
-const UnionSchemaBuilder_js_1 = require("./builders/UnionSchemaBuilder.js");
-Object.defineProperty(exports, "union", { enumerable: true, get: function () { return UnionSchemaBuilder_js_1.union; } });
-const FunctionSchemaBuilder_js_1 = require("./builders/FunctionSchemaBuilder.js");
-Object.defineProperty(exports, "func", { enumerable: true, get: function () { return FunctionSchemaBuilder_js_1.func; } });
-exports.default = {
-    SchemaRegistry: schemaRegistry_js_1.default,
-    array: ArraySchemaBuilder_js_1.array,
-    boolean: BooleanSchemaBuilder_js_1.boolean,
-    number: NumberSchemaBuilder_js_1.number,
-    object: ObjectSchemaBuilder_js_1.object,
-    string: StringSchemaBuilder_js_1.string,
-    union: UnionSchemaBuilder_js_1.union,
-    func: FunctionSchemaBuilder_js_1.func
-};
+export { AnySchemaBuilder } from './builders/AnySchemaBuilder.js';
+export { ArraySchemaBuilder } from './builders/ArraySchemaBuilder.js';
+export { BooleanSchemaBuilder } from './builders/BooleanSchemaBuilder.js';
+export { DateSchemaBuilder } from './builders/DateSchemaBuilder.js';
+export { FunctionSchemaBuilder } from './builders/FunctionSchemaBuilder.js';
+export { ObjectSchemaBuilder } from './builders/ObjectSchemaBuilder.js';
+export { NumberSchemaBuilder } from './builders/NumberSchemaBuilder.js';
+export { StringSchemaBuilder } from './builders/StringSchemaBuilder.js';
+export { UnionSchemaBuilder } from './builders/UnionSchemaBuilder.js';
+export { SchemaBuilder } from './builders/SchemaBuilder.js';
+export { any } from './builders/AnySchemaBuilder.js';
+export { array } from './builders/ArraySchemaBuilder.js';
+export { boolean } from './builders/BooleanSchemaBuilder.js';
+export { date } from './builders/DateSchemaBuilder.js';
+export { func } from './builders/FunctionSchemaBuilder.js';
+export { number } from './builders/NumberSchemaBuilder.js';
+export { object } from './builders/ObjectSchemaBuilder.js';
+export { string } from './builders/StringSchemaBuilder.js';
+export { union } from './builders/UnionSchemaBuilder.js';

package/dist/utils/transaction.d.ts

@@ -0,0 +1,46 @@
+export type TransactionOptions = {
+    /**
+     * An optional callback returning boolean. Called for every
+     * nested object's property (recursively) which is not
+     * null `Object`. Using this function you can define if `child`
+     * should be wrapped with transaction. It is useful for
+     * some cases like Error, Map, etc. when you want to preserve a link,
+     * instead of creation of the new transaction.
+     * By default it's filtering all instances inheriting from Error and RegExp
+     * If `true` is returned from this function `child` will not be wrapped with
+     * nested transaction object.
+     */
+    shouldNotWrapWithTransaction?: (child: any) => boolean;
+};
+export type Transaction<T> = {
+    /**
+     * Transaction object you can modify (equals to `initial` right after the call).
+     * All changes to `object` will not be reflected to `initial` until `commit`
+     * is called.
+     */
+    object: T;
+    /**
+     * Commits transaction, all changes to `object` will be reflected to `initial`
+     * after the call of this function.
+     */
+    commit: () => T;
+    /**
+     * Rollbacks transaction moving it to the initial state (`object` will be equal to `initial`
+     * after the call of this function).
+     */
+    rollback: () => T;
+    /**
+     * Returns `true` if there are any changes to `object` which makes is different from `initial`
+     */
+    isDirty: () => boolean;
+};
+/**
+ * Starts transaction over the `initial` object.
+ */
+export declare const transaction: <T extends {}>(initial: T, options?: TransactionOptions) => Transaction<T>;
+/**
+ * Checks if `obj` is instance of transaction
+ * @param obj object to check if it's a transaction
+ * @returns
+ */
+export declare const isTransaction: (obj: any) => any;