@bemedev/types/lib/types/objects.d.ts

Type definitions for Bemedev projects

import type { Equals, Keys, KeyTypes, KeyTypesFrom, PrimitiveObjectMap } from './commons.types';
import type { AllowedNames, DeepNotReadonly, DeepNotSubType, DeepOmit, DeepPartial, DeepReadonly, DeepRequired, NotReadonly, NotSubType, Ra, Rn, Ru, SubType, ValuesOf } from './objects.types';
export declare const objects: import("../utils.js").FnBasic<(_?: object | undefined) => object, {
    trueObject: import("../utils.js").FnBasic<(_?: import("./objects.types").TrueObject | undefined) => import("./objects.types").TrueObject, object & {
        readonly forceCast: (_?: unknown) => import("./objects.types").TrueObject;
        readonly dynamic: <U extends import("./objects.types").TrueObject>(_?: U | undefined) => U;
        readonly is: <U>(_?: U | undefined) => U extends import("./objects.types").TrueObject ? true : false;
        readonly type: import("./objects.types").TrueObject;
    }>;
    keysOf: import("../utils.js").FnBasic<(<T extends object>(_?: T) => (keyof T)[]), {
        readonly union: <T extends object>(_?: T) => keyof T;
    }>;
    values: import("../utils.js").FnBasic<(<T extends object>(_?: T) => T[keyof T][]), {
        readonly union: <T extends object>(_?: T) => T[keyof T];
    }>;
    entries: <T extends object>(_?: T) => [keyof T, T[keyof T]][];
    byKey: <T extends object, K extends keyof T>(_?: T, __?: K) => T[K];
    keyTypes: import("../utils.js").FnBasic<(_?: KeyTypes | undefined) => KeyTypes, {
        from: <T extends KeyTypes>(_?: T) => KeyTypesFrom<T>;
    } & {
        readonly forceCast: (_?: unknown) => KeyTypes;
        readonly dynamic: <U extends KeyTypes>(_?: U | undefined) => U;
        readonly is: <U>(_?: U | undefined) => U extends KeyTypes ? true : false;
        readonly type: KeyTypes;
    }>;
    hasKeys: import("../utils.js").FnBasic<(<T extends object, K extends Keys[]>(_?: T, ...__: K) => K[number] extends keyof T ? true : false), {
        readonly typings: <K extends KeyTypes>(_?: K) => <T extends object>(_?: T) => T extends KeyTypesFrom<K> ? true : false;
        readonly all: <T extends object, K extends Keys[]>(_?: T, ...__: K) => Equals<K[number], keyof T>;
    }>;
    omit: import("../utils.js").FnBasic<(<T, K extends Keys[]>(_?: T, ...__: K) => Omit<T, K[number]>), {
        readonly const: import("../utils.js").FnBasic<(<const T extends object, K extends (keyof T)[]>(_?: T, ...__: K) => Omit<T, K[number]>), {
            readonly is: <const T, K extends (keyof T)[]>(_?: T, ...__: K) => <U>(_?: U) => U extends Omit<T, K[number]> ? true : false;
        }>;
        readonly is: <T, K extends Keys[]>(_?: T, ...__: K) => <U>(_?: U) => U extends Omit<T, K[number]> ? true : false;
        readonly by: import("../utils.js").FnBasic<(<T extends object, K extends any[]>(_?: T, ...__: K) => NotSubType<T, K[number]>), {
            readonly is: <T extends object, K extends any[]>(_?: T, ...__: K) => <U>(_?: U) => U extends NotSubType<T, K[number]> ? true : false;
            readonly const: import("../utils.js").FnBasic<(<const T extends object, K extends ValuesOf<T>[]>(_?: T, ...__: K) => NotSubType<T, K[number]>), {
                readonly is: <const T extends object, K extends ValuesOf<T>[]>(_?: T, ...__: K) => <U>(_?: U) => U extends NotSubType<T, K[number]> ? true : false;
            }>;
        }>;
        readonly deep: import("../utils.js").FnBasic<(<T, K extends Keys[]>(_?: T, ...__: K) => DeepOmit<T, K[number]>), {
            readonly is: <T, K extends Keys[]>(_?: T, ...__: K) => <U>(_?: U) => U extends DeepOmit<T, K[number]> ? true : false;
            readonly const: import("../utils.js").FnBasic<(<const T extends object, K extends (keyof T)[]>(_?: T, ...__: K) => DeepOmit<T, K[number]>), {
                readonly is: <const T extends object, K extends (keyof T)[]>(_?: T, ...__: K) => <U>(_?: U) => U extends DeepOmit<T, K[number]> ? true : false;
            }>;
            readonly by: import("../utils.js").FnBasic<(<T extends object, K extends any[]>(_?: T, ...__: K) => DeepNotSubType<T, K[number]>), {
                readonly is: <T extends object, K extends any[]>(_?: T, ...__: K) => <U>(_?: U) => U extends DeepNotSubType<T, K[number]> ? true : false;
                readonly const: import("../utils.js").FnBasic<(<const T extends object, K extends ValuesOf<T>[]>(_?: T, ...__: K) => DeepNotSubType<T, K[number]>), {
                    readonly is: <const T extends object, K extends ValuesOf<T>[]>(_?: T, ...__: K) => <U>(_?: U) => U extends DeepNotSubType<T, K[number]> ? true : false;
                }>;
            }>;
        }>;
    }>;
    reverse: <T extends Record<Keys, Keys>>(_?: T) => { [K in keyof T as T[K]]: K; };
    readonly: import("../utils.js").FnBasic<(<T extends object>(_?: T) => Readonly<T>), {
        readonly forceCast: <T extends object>(_?: unknown) => Readonly<T>;
        readonly dynamic: <T extends Readonly<T>>(_?: T) => T;
        readonly type: object;
        readonly is: <T extends object>(_?: T) => T extends Readonly<T> ? true : false;
        readonly not: import("../utils.js").FnBasic<(<const T extends object>(_?: T) => NotReadonly<T>), {
            readonly is: <const T extends object>(_?: T) => T extends NotReadonly<T> ? true : false;
        }>;
        readonly deep: import("../utils.js").FnBasic<(<T extends object>(_?: T) => DeepReadonly<T>), {
            readonly not: import("../utils.js").FnBasic<(<const T extends object>(_?: T) => DeepNotReadonly<T>), {
                readonly is: <const T extends object>(_?: T) => T extends DeepNotReadonly<T> ? true : false;
            }>;
            readonly is: <T extends object>(_?: T) => T extends DeepReadonly<T> ? true : false;
        }>;
    }>;
    freeze: import("../utils.js").FnBasic<(<T extends object>(_?: T) => Readonly<T>), {
        readonly forceCast: <T extends object>(_?: unknown) => Readonly<T>;
        readonly dynamic: <T extends Readonly<T>>(_?: T) => T;
        readonly type: object;
        readonly is: <T extends object>(_?: T) => T extends Readonly<T> ? true : false;
        readonly not: import("../utils.js").FnBasic<(<const T extends object>(_?: T) => NotReadonly<T>), {
            readonly is: <const T extends object>(_?: T) => T extends NotReadonly<T> ? true : false;
        }>;
        readonly deep: import("../utils.js").FnBasic<(<T extends object>(_?: T) => DeepReadonly<T>), {
            readonly not: import("../utils.js").FnBasic<(<const T extends object>(_?: T) => DeepNotReadonly<T>), {
                readonly is: <const T extends object>(_?: T) => T extends DeepNotReadonly<T> ? true : false;
            }>;
            readonly is: <T extends object>(_?: T) => T extends DeepReadonly<T> ? true : false;
        }>;
    }>;
    required: import("../utils.js").FnBasic<(<T extends object>(_?: T) => Required<T>), {
        readonly deep: import("../utils.js").FnBasic<(<T extends object>(_: T) => DeepRequired<T>), {
            readonly is: <T extends object>(_?: T) => T extends DeepRequired<T> ? true : false;
        }>;
        readonly is: <T extends object>(_?: T) => T extends Required<T> ? true : false;
    }>;
    partial: import("../utils.js").FnBasic<(<T extends object>(_: T) => Partial<T>), {
        readonly deep: <T extends object>(_: T) => DeepPartial<T>;
    }>;
    pick: import("../utils.js").FnBasic<(<T extends object, K extends (keyof T)[]>(_: T, ...__: K) => Pick<T, K[number]>), {
        readonly by: import("../utils.js").FnBasic<(<T extends object, K>(_?: T, __?: K) => SubType<T, K>), {
            readonly keys: <T extends object, K>(_: T, __?: K) => AllowedNames<T, K>;
        }>;
    }>;
    ru: import("../utils.js").FnBasic<(_?: Ru | undefined) => Ru, object & {
        readonly forceCast: (_?: unknown) => Ru;
        readonly dynamic: <U extends Ru>(_?: U | undefined) => U;
        readonly is: <U>(_?: U | undefined) => U extends Ru ? true : false;
        readonly type: Ru;
    }>;
    rn: import("../utils.js").FnBasic<(_?: Rn | undefined) => Rn, object & {
        readonly forceCast: (_?: unknown) => Rn;
        readonly dynamic: <U extends Rn>(_?: U | undefined) => U;
        readonly is: <U>(_?: U | undefined) => U extends Rn ? true : false;
        readonly type: Rn;
    }>;
    ra: import("../utils.js").FnBasic<(_?: Ra | undefined) => Ra, object & {
        readonly forceCast: (_?: unknown) => Ra;
        readonly dynamic: <U extends Ra>(_?: U | undefined) => U;
        readonly is: <U>(_?: U | undefined) => U extends Ra ? true : false;
        readonly type: Ra;
    }>;
    primitive: import("../utils.js").FnBasic<(_?: PrimitiveObjectMap | undefined) => PrimitiveObjectMap, object & {
        readonly forceCast: (_?: unknown) => PrimitiveObjectMap;
        readonly dynamic: <U extends PrimitiveObjectMap>(_?: U | undefined) => U;
        readonly is: <U>(_?: U | undefined) => U extends PrimitiveObjectMap ? true : false;
        readonly type: PrimitiveObjectMap;
    }>;
} & {
    readonly forceCast: (_?: unknown) => object;
    readonly dynamic: <U extends object>(_?: U | undefined) => U;
    readonly is: <U>(_?: U | undefined) => U extends object ? true : false;
    readonly type: object;
}>;
//# sourceMappingURL=objects.d.ts.map