@bemedev/types/lib/functions/commons.d.ts

Type definitions for Bemedev projects

import type { Checker, DeepNotReadonly, DeepPartial, DeepReadonly, DeepRequired, Defaulted, Fn, Neverify, NonN, NotReadonly, NotUndefined, Primitive, PrimitiveObject } from '../types/types';
import { Checker2 } from './../types/commons.types';
export declare const commons: import("../utils.js").FnBasic<(<T>(value: unknown) => T), {
    readonly partial: import("../utils.js").FnBasic<(<T>(value: T) => Partial<T>), {
        readonly deep: <T>(value: T) => DeepPartial<T>;
    }>;
    readonly const: <const T>(value: T) => T;
    readonly clone: <T extends PrimitiveObject>(object: T) => T;
    readonly identity: <T>(value: T) => T;
    readonly isDefined: <T>(value: T) => value is NonNullable<T>;
    readonly isUndefined: (value: unknown) => value is undefined;
    readonly isNull: (value: unknown) => value is null;
    readonly unknown: <T>(value: unknown) => T;
    readonly any: import("../utils.js").FnBasic<(arg: any) => any, object & {
        readonly forceCast: (arg: unknown) => any;
        readonly dynamic: <U extends any>(arg: U) => U;
    }>;
    readonly neverify: <T>(value: T) => Neverify<T>;
    readonly required: import("../utils.js").FnBasic<(<T>(value: T) => NotUndefined<T>), {
        readonly deep: <T extends object | undefined>(value: T) => DeepRequired<T>;
    }>;
    readonly readonly: import("../utils.js").FnBasic<(<T>(value: T) => Readonly<T>), {
        readonly deep: import("../utils.js").FnBasic<(<T extends object>(value: T) => DeepReadonly<T>), {
            readonly not: <const T extends object>(value: T) => DeepNotReadonly<T>;
        }>;
        readonly not: <T extends object>(value: T) => NotReadonly<T>;
    }>;
    readonly primitive: import("../utils.js").FnBasic<(arg: Primitive) => Primitive, {
        readonly is: (value: unknown) => value is Primitive;
    } & {
        readonly forceCast: (arg: unknown) => Primitive;
        readonly dynamic: <U extends Primitive>(arg: U) => U;
    }>;
    readonly primitiveObject: import("../utils.js").FnBasic<(arg: PrimitiveObject) => PrimitiveObject, {
        readonly is: (object: any) => object is PrimitiveObject;
    } & {
        readonly forceCast: (arg: unknown) => PrimitiveObject;
        readonly dynamic: <U extends PrimitiveObject>(arg: U) => U;
    }>;
    readonly function: import("../utils.js").FnBasic<(<T extends any[], R = any>(..._: [...T, R]) => (value: Fn<T, R>) => Fn<T, R>), {
        readonly is: import("../utils.js").FnBasic<(value: unknown) => value is Fn, {
            readonly strict: <T extends any[] = any[], R = any>(fn: Checker<Fn<T, R>>) => (value: unknown) => value is Fn<T, R>;
        }>;
        readonly forceCast: <T extends any[], R = any>(value: unknown) => Fn<T, R>;
        readonly dynamic: <T extends any[], R = any>(value: Fn<T, R>) => Fn<T, R>;
        readonly checker: import("../utils.js").FnBasic<(arg: Checker) => Checker, {
            /**
             * Very low
             * Checks if value is a function with one argument
             * @param value value to check
             * @returns true if value is a function with one argument
             */
            readonly is: <T = unknown>(value: unknown) => value is Checker2<T>;
            readonly byType: import("../utils.js").FnBasic<(<T>(checker: Checker2<T>) => Checker2<T>), {
                readonly forceCast: <T>(value: Checker<T>) => Checker2<T>;
            }>;
        } & {
            readonly forceCast: (arg: unknown) => Checker;
            readonly dynamic: <U extends Checker>(arg: U) => U;
        }>;
    }>;
    readonly undefined: undefined;
    readonly null: null;
    readonly symbol: import("../utils.js").FnBasic<(arg: symbol) => symbol, {
        readonly is: (value: unknown) => value is symbol;
    } & {
        readonly forceCast: (arg: unknown) => symbol;
        readonly dynamic: <U extends symbol>(arg: U) => U;
    }>;
    readonly date: import("../utils.js").FnBasic<(arg: Date) => Date, {
        readonly is: (value: unknown) => value is Date;
    } & {
        readonly forceCast: (arg: unknown) => Date;
        readonly dynamic: <U extends Date>(arg: U) => U;
    }>;
    readonly undefiny: <T>(value?: T) => T | undefined;
    readonly defaulted: <T, const U extends NonN<T>>(value: T, defaultValue: U) => Defaulted<T, U>;
}>;
//# sourceMappingURL=commons.d.ts.map