@tstdl/base 0.92.124 → 0.92.126

package/types/utils/cryptography.d.ts

@@ -1,122 +0,0 @@
-import type { BinaryData, TypedExtract } from '../../types.js';
-import type { ReadonlyTuple } from 'type-fest';
-export type AesMode = 'CBC' | 'CTR' | 'GCM' | 'KW';
-export type EcdsaCurve = 'P-256' | 'P-384' | 'P-521';
-export type HashAlgorithm = 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';
-export type SymmetricAlgorithm = `AES-${AesMode}`;
-export type AsymmetricAlgorithm = 'RSASSA-PKCS1-v1_5' | 'RSA-PSS' | 'RSA-OAEP' | 'ECDSA' | 'ECDH' | 'NODE-DSA' | 'NODE-DH' | 'NODE-ED25519' | 'NODE-ED448';
-export type CryptionAlgorithm = Parameters<typeof globalThis.crypto.subtle.encrypt>[0];
-export type SignAlgorithm = Parameters<typeof globalThis.crypto.subtle.sign>[0];
-export type KeyAlgorithm = Parameters<typeof globalThis.crypto.subtle.generateKey>[0];
-export type DeriveAlgorithm = Parameters<typeof globalThis.crypto.subtle.deriveBits>['0'];
-export type KeyType = 'raw' | 'pkcs8' | 'spki' | 'jwk';
-export type Key = JsonWebKey | BinaryData;
-export type ScryptOptions = {
-    cost?: number;
-    blockSize?: number;
-    parallelization?: number;
-    maximumMemory?: number;
-};
-export interface CryptionResult {
-    toBuffer(): Promise<ArrayBuffer>;
-    toHex(): Promise<string>;
-    toBase64(): Promise<string>;
-    toBase64Url(): Promise<string>;
-    toZBase32(): Promise<string>;
-}
-export interface DecryptionResult extends CryptionResult {
-    toUtf8(): Promise<string>;
-}
-export type DigestResult = CryptionResult;
-export type SignResult = CryptionResult;
-/**
- * Encrypt data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param key key
- * @param data data to encrypt. Encodes string to utf8
- */
-export declare function encrypt(algorithm: CryptionAlgorithm, key: CryptoKey, data: BinaryData | string): CryptionResult;
-/**
- * Decrypt data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param key key
- * @param data data to decrypt
- */
-export declare function decrypt(algorithm: CryptionAlgorithm, key: CryptoKey, bytes: BinaryData): DecryptionResult;
-/**
- * Hashes data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param data data to encrypt. Encodes string to utf8
- */
-export declare function digest(algorithm: HashAlgorithmIdentifier, data: BinaryData | string): DigestResult;
-/**
- * Signs data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param key key
- * @param data data to sign
- */
-export declare function sign(algorithm: SignAlgorithm, key: CryptoKey, data: BinaryData | string): SignResult;
-/**
- * Verifies data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param key key
- * @param signature signature
- * @param data data to verify using provided signature
- */
-export declare function verify(algorithm: SignAlgorithm, key: CryptoKey, signature: BinaryData | string, data: BinaryData | string): Promise<boolean>;
-/**
- * Imports a HMAC CryptoKey
- * @param algorithm hash algorithm
- * @param key JWK or binary key
- * @param extractable whether the key can be used for exportKey
- */
-export declare function importHmacKey(algorithm: HashAlgorithmIdentifier, key: Key | string, extractable?: boolean): Promise<CryptoKey>;
-/**
- * Imports a CryptoKey for symmetric encryption
- * @param algorithm symmetric algorithm
- * @param length key length
- * @param key JWK or binary key
- * @param extractable whether the key can be used for exportKey
- */
-export declare function importSymmetricKey(algorithm: SymmetricAlgorithm, length: 128 | 192 | 256, key: Key | string, extractable?: boolean): Promise<CryptoKey>;
-/**
- * Imports an ECDSA CryptoKey
- * @param curve ECDSA curve
- * @param key JWK or DER encoded key
- * @param extractable whether the key can be used for exportKey
- */
-export declare function importEcdsaKey(curve: EcdsaCurve, key: Key | string, extractable?: boolean): Promise<CryptoKey>;
-/**
- * Import a pbkdf2 CryptoKey
- * @param key binary key
- * @param extractable whether the key can be used for exportKey
- */
-export declare function importPbkdf2Key(key: BinaryData | string, extractable?: boolean): Promise<CryptoKey>;
-/**
- * Generates a new ECDSA CryptoKeyPair
- * @param curve ECDSA cruve to use
- * @param extractable whether the key can be used for exportKey
- * @param usages whether to generate a key for signing, verifiying or both. Defaults to both
- */
-export declare function generateEcdsaKey(curve: EcdsaCurve, extractable?: boolean, usages?: TypedExtract<KeyUsage, 'sign' | 'verify'>[]): Promise<CryptoKeyPair>;
-/**
- * Generates a pbkdf2 CryptoKey
- * @param extractable whether the key can be used for exportKey
- */
-export declare function generatePbkdf2Key(extractable?: boolean): Promise<CryptoKey>;
-/**
- * Derive byte array from key
- * @param length length in bytes
- * @param algorithm algorithm to derive with
- * @param baseKey key to derive from
- */
-export declare function deriveBytes(algorithm: DeriveAlgorithm, baseKey: CryptoKey, length: number): Promise<Uint8Array>;
-/**
- * Derive multiply byte arrays from key
- * @param algorithm algorithm to derive with
- * @param baseKey key to derive from
- * @param length length of each Uint8Array in bytes, if single number is provided, it is used for every array
- * @param count how many Uint8Arrays to derive
- */
-export declare function deriveBytesMultiple<const Lengths extends readonly number[]>(algorithm: DeriveAlgorithm, baseKey: CryptoKey, lengths: Lengths): Promise<ReadonlyTuple<Uint8Array, Lengths['length']>>;
-export declare function deriveBytesMultiple<const C extends number>(algorithm: DeriveAlgorithm, baseKey: CryptoKey, length: C, count: number): Promise<ReadonlyTuple<Uint8Array, C>>;

package/types/utils/encoding.d.ts

@@ -1,36 +0,0 @@
-import type { BinaryData } from '../../types.js';
-/**
- * Encodes text to utf8
- * @param text text to encode
- * @returns utf8 encoded text
- */
-export declare function encodeUtf8(text: string): Uint8Array;
-/**
- * Encodes text stream to utf8 bytes stream
- */
-export declare function encodeUtf8Stream(): TransformStream<string, Uint8Array>;
-/**
- * Decodes buffer to string
- * @param buffer buffer to decode
- * @param encoding encoding, defaults to utf8
- * @returns decoded string
- */
-export declare function decodeText(buffer: BinaryData, encoding?: string, options?: TextDecoderOptions): string;
-/**
- * Transforms binary stream to string stream
- * @param encoding encoding, defaults to utf8
- * @returns stream of decoded string
- */
-export declare function decodeTextStream(encoding?: string, options?: TextDecoderOptions): TransformStream<BinaryData, string>;
-/**
- * Encodes buffer to hex
- * @param buffer buffer to encode
- * @returns hex encoded string
- */
-export declare function encodeHex(buffer: BinaryData): string;
-/**
- * Decodes hex string to buffer
- * @param hex hex string to decode
- * @returns decoded buffer
- */
-export declare function decodeHex(hex: string): Uint8Array;

package/types/utils/enum.d.ts

@@ -1,9 +0,0 @@
-import type { EnumerationEntries, EnumerationKey, EnumerationObject, EnumerationValue } from '../../types.js';
-export declare function enumValueName<T extends EnumerationObject>(enumeration: T, value: T[keyof T]): EnumerationKey<T>;
-export declare function enumEntries<T extends EnumerationObject>(enumeration: T): EnumerationEntries<T>;
-export declare function enumKeys<T extends EnumerationObject>(enumeration: T): EnumerationKey<T>[];
-export declare function enumValues<T extends EnumerationObject>(enumeration: T): EnumerationValue<T>[];
-export declare function randomEnumValue<T extends EnumerationObject>(enumeration: T): EnumerationValue<T>;
-export declare function reversedEnum<T extends EnumerationObject>(enumeration: T): {
-    [P in keyof T as T[P]]: P;
-};

package/types/utils/equals.d.ts

@@ -1,30 +0,0 @@
-import type { BinaryData } from '../../types.js';
-import type { Comparator } from './sort.js';
-export interface Equals<T = unknown> {
-    [Equals.symbol](other: T): boolean;
-}
-declare const equalsSymbol: unique symbol;
-export declare const Equals: {
-    readonly symbol: typeof equalsSymbol;
-};
-export type ArrayEqualsComparator<A, B> = (a: A, b: B) => boolean;
-export type ArrayEqualsOptions<A, B> = {
-    sort?: Comparator<A | B>;
-    comparator?: ArrayEqualsComparator<A, B>;
-};
-export declare function strictEquals(a: any, b: any): boolean;
-export declare function arrayEquals<A, B>(a: readonly A[], b: readonly B[], options?: ArrayEqualsOptions<A, B>): boolean;
-export type EqualsOptions = {
-    deep?: boolean;
-    arrayDeep?: boolean;
-    sortArray?: boolean;
-    coerceStrings?: boolean;
-    checkPrototype?: boolean;
-};
-export declare function equals(a: any, b: any, options?: EqualsOptions): boolean;
-export declare function equals(a: any, b: any, options?: EqualsOptions, __internal?: any): boolean;
-/**
- * compares to binary types for equal content
- */
-export declare function binaryEquals(bufferA: BinaryData, bufferB: BinaryData): boolean;
-export {};

package/types/utils/event-loop.d.ts

@@ -1,4 +0,0 @@
-import type { CancellationSignal } from '../../cancellation/token.js';
-import type { Logger } from '../../logger/index.js';
-export declare function measureEventLoopDelay(): Promise<number>;
-export declare function runEventLoopWatcher(logger: Logger, cancellationSignal: CancellationSignal): void;

package/types/utils/format-error.d.ts

@@ -1,24 +0,0 @@
-import type { UndefinableJson } from '../../types.js';
-export type FormatErrorOptions = {
-    /**
-     * Include error name in message
-     */
-    includeName?: boolean;
-    /**
-     * Include all error properties beside name and message
-     */
-    includeRest?: boolean | 'if-no-extra-info';
-    /**
-     * Include extraInfo from errors implementing {@link ErrorExtraInfo}
-     */
-    includeExtraInfo?: boolean;
-    /**
-     * Include stack trace
-     */
-    includeStack?: boolean;
-};
-export interface ErrorExtraInfo {
-    /** Format extra data (without message and stack) as JSON */
-    getExtraInfo(): UndefinableJson | undefined;
-}
-export declare function formatError(error: any, options?: FormatErrorOptions): string;

package/types/utils/function/class.d.ts

@@ -1,6 +0,0 @@
-import type { AbstractConstructor } from '../../../types.js';
-declare class EmptyClass {
-}
-export declare function getClassOfName(name: string): typeof EmptyClass;
-export declare function getClassOfName<T extends AbstractConstructor>(name: string, extend: T): T;
-export {};

package/types/utils/function/memoize.d.ts

@@ -1,36 +0,0 @@
-import type { Constructor } from '../../../types.js';
-export type MemoizeOptions = {
-    /** Use WeakMap instead of Map for caching. Can be used with object parameters only */
-    weak?: boolean;
-};
-/**
- * Memoizes a function with an arbitrary number of parameters. If you only need a single parameter, {@link memoizeSingle} is faster
- * @param fn function memoize
- * @returns memoized function
- */ export declare function memoize<Fn extends (...parameters: any[]) => any>(fn: Fn, options?: MemoizeOptions): Fn;
-/**
- * Memoizes a function with a single parameter. Faster than {@link memoize}
- * @param fn function memoize
- * @returns memoized function
- */
-export declare function memoizeSingle<Fn extends (parameter: any) => any>(fn: Fn, options?: MemoizeOptions): Fn;
-export declare function memoizeClass<T extends Constructor>(type: T, options?: MemoizeOptions): (...parameters: ConstructorParameters<T>) => InstanceType<T>;
-export declare function memoizeClassSingle<T extends Constructor<any, [any]>>(type: T, options?: MemoizeOptions): (...parameters: ConstructorParameters<T>) => InstanceType<T>;
-/**
- * Memoizes an accessor (getter)
- *
- * @example
- * ```typescript
- * class MyClass {
- *   @Memoize()
- *   get myValue() {
- *     // expensive calculation
- *     return 123;
- *   }
- * }
- * ```
- *
- * @remarks
- * The getter will be called only once for each instance of the class.
- */
-export declare function Memoize(): MethodDecorator;

package/types/utils/iterable-helpers/take-until.d.ts

@@ -1,2 +0,0 @@
-import type { CancellationSignal } from '../../../cancellation/token.js';
-export declare function takeUntil<T>(iterable: Iterable<T>, cancellationSignal: CancellationSignal): IterableIterator<T>;

package/types/utils/math.d.ts

@@ -1,93 +0,0 @@
-import { type RandomNumberGeneratorFn } from '../../random/number-generator/random-number-generator-function.js';
-/**
- * Generate a random float in interval [min, max).
- * @param min minimum value
- * @param max maximum value
- * @param generator Random number generator to use, defaults to `Math.random`. Must return a number in interval [0, 1).
- * @returns random number (float)
- */
-export declare function randomFloat(min: number, max: number, generator?: RandomNumberGeneratorFn): number;
-/**
- * Generate a random integer in interval [min, max].
- * @param min minimum value
- * @param max maximum value
- * @param generator random number generator to use, defaults to `Math.random`. Must return a number in interval [0, 1)
- * @returns random number (integer)
- */
-export declare function randomInt(min: number, max: number, generator?: RandomNumberGeneratorFn): number;
-/**
- * Calculate the sum of all values.
- * @param values values to sum
- * @returns sum
- */
-export declare function sum(values: number[]): number;
-/**
- * Calculate the average of all values.
- * @param values values to average
- * @returns average
- */
-export declare function average(values: number[]): number;
-/**
- * Calculate the minimum value.
- * @param values values to get minimum from
- * @returns minimum
- */
-export declare function minimum(values: number[]): number;
-/**
- * Calculate the maximum value.
- * @param values values to get maximum from
- * @returns maximum
- */
-export declare function maximum(values: number[]): number;
-/**
- * Round number to specified decimals.
- * @param value value to round
- * @param decimals number of decimals to round to
- * @returns rounded number
- */
-export declare function round(value: number, decimals: number): number;
-/**
- * Linearly interpolate the interval [fromLow, fromHigh] into [toLow, toHigh].
- * @param value value to interpolate
- * @param fromLow source lower bound
- * @param fromHigh source upper bound
- * @param toLow target lower bound
- * @param toHigh target upper bound
- * @returns interpolated value
- */
-export declare function linearInterpolate(value: number, fromLow: number, fromHigh: number, toLow: number, toHigh: number): number;
-/**
- * Linearly interpolate [0, 1] into an interval.
- * @param value value to interpolate in interval [0, 1]
- * @param low lower bound
- * @param high upper bound
- * @returns interpolated value
- */
-export declare function linearInterpolateFloat(value: number, low: number, high: number): number;
-/**
- * Clamps a number between two numbers.
- * @param value value to clamp
- * @param minimum lower bound
- * @param maximum upper bound
- * @returns clamped value
- */
-export declare function clamp(value: number, minimum: number, maximum: number): number;
-/**
- * Calculates the nth-root of a number.
- *
- * Warning: negative values are handled as if they were positive but returned with an negative sign.
- * @param base base
- * @param root root
- * @returns nth-root of base
- */
-export declare function nthRoot(base: number, root: number): number;
-/**
- *
- * @param t Time in interval [0, 1]
- * @param attenuationExponentStart Sensible values are between 1 (linear attenuation) and ~10 (no attenuation until t = ~0.9, then sharply increasing attenuation)
- * @param attenuationExponentEnd Sensible values are between 1 (linear attenuation) and ~10 (no attenuation until t = ~0.9, then sharply increasing attenuation)
- * @param deadzoneWidthStart Deadzone width to add in front of 0.5. Sensible values are between 0 and 0.5
- * @param deadzoneWidthEnd Deadzone width to add to interval [0.5, 1]. Sensible values are between 0 and 0.5
- * @returns Coefficient in interval [0, 1]
- */
-export declare function getAttenuationCoefficient(t: number, attenuationExponentStart: number | null, attenuationExponentEnd: number | null, deadzoneWidthStart?: number, deadzoneWidthEnd?: number): number;

package/types/utils/merge.d.ts

@@ -1,19 +0,0 @@
-import type { IsEqual, MergeDeep, MergeDeepOptions as TypeFestMergeDeepOptions } from 'type-fest';
-import type { If, Merge, Record, TypedOmit } from '../../types.js';
-type BaseType = Record | any[] | Map<any, any> | Set<any>;
-export declare function merge<A extends BaseType, B extends BaseType>(a: A | undefined, b: B | undefined): A extends (infer T)[] ? B extends (infer U)[] ? (T | U)[] : never : A extends Map<infer K, infer V> ? B extends Map<infer K2, infer V2> ? Map<K | K2, V | V2> : never : A extends Set<infer T> ? B extends Set<infer U> ? Set<T | U> : never : A extends Record ? B extends Record ? Merge<A, B> : never : never;
-export type MergeDeepOptions = TypedOmit<TypeFestMergeDeepOptions, 'arrayMergeMode'> & {
-    arrayMergeMode?: TypeFestMergeDeepOptions['arrayMergeMode'] | 'mergeItems';
-};
-export declare function mergeDeep<A extends Record, B extends Record, Options extends MergeDeepOptions = {
-    arrayMergeMode: 'spread';
-    recurseIntoArrays: true;
-}>(a: A, b: B, options?: Options): MergeDeep<A, B, {
-    arrayMergeMode: If<IsEqual<Options['arrayMergeMode'], 'mergeItems'>, 'spread', Exclude<Options['arrayMergeMode'], 'mergeItems'>>;
-    recurseIntoArrays: Options['recurseIntoArrays'];
-}>;
-export declare function mergeArray<A extends readonly any[], B extends readonly any[], Mode extends NonNullable<MergeDeepOptions['arrayMergeMode']>>(a: A, b: B, mode: Mode): MergeDeep<A, B, {
-    recurseIntoArrays: true;
-    arrayMergeMode: If<IsEqual<Mode, 'mergeItems'>, 'spread', Exclude<Mode, 'mergeItems'>>;
-}>;
-export {};

package/types/utils/object/decycle.d.ts

@@ -1,16 +0,0 @@
-import type { Record } from '../../../types.js';
-export type Decycled<T> = {
-    __type: T;
-} & Record<string>;
-/**
- * Replaces cycles (circular references) in objects with JSONPath
- * @param value object to decycle
- * @param replacer replace values. Like JSON.stringify(value, *replacer*)
- */
-export declare function decycle<T>(value: T, replacer?: (value: any) => any): Decycled<T>;
-/**
- * Replaces JSONPath in objects with their reference
- * @param value object to recycle
- */
-export declare function recycle<T = any>(value: Decycled<T>, clone?: boolean): T;
-export declare function recycle<T = any>(value: any, clone?: boolean): T;

package/types/utils/object/dereference.d.ts

@@ -1,34 +0,0 @@
-import { type JsonPathInput } from '../../../json-path/index.js';
-export type DereferenceOptions = {
-    optional?: boolean;
-};
-/**
- * Compiles a dereferencer for a specific reference
- * @param object object to dereference
- * @param reference path to property in dot notation or {@link JsonPath}
- * @returns referenced value
- */
-export declare function compileDereferencer(reference: JsonPathInput, options?: DereferenceOptions): (object: object) => unknown;
-/**
- * Dereference a reference
- *
- * @description useful if you dereference a reference a few times at most
- *
- * also take a look at {@link getCachedDereference} and {@link compileDereferencer} if you need to dereference multiple times
- * @param object object to dereference
- * @param reference path to property in dot notation or {@link JsonPath}
- * @returns referenced value
- */
-export declare function dereference(object: object, reference: JsonPathInput, options?: DereferenceOptions): unknown;
-/**
- * Cached version of {@link dereference}. It caches the internally used dereferencer, but it does *not* cache the referenced value
- *
- * @description
- * useful if you dereference multiple references, each multiple times
- *
- * also take a look at {@link dereference} and {@link compileDereferencer} for other use cases
- * @param object object to dereference
- * @param reference path to property in dot notation or {@link JsonPath}
- * @returns referenced value
- */
-export declare function getCachedDereference(options?: DereferenceOptions): typeof dereference;

package/types/utils/object/forward-ref.d.ts

@@ -1,21 +0,0 @@
-import type { AbstractConstructor } from '../../../types.js';
-declare const isForwardRef: unique symbol;
-export type ForwardRefTypeHint = 'object' | 'function' | AbstractConstructor;
-export type ForwardRefOptions<T extends object = object> = {
-    reference?: T;
-    initializer?: () => T;
-    /** Due to limitations of Proxy, there can be some issues if proxy is created with a target of the "wrong" type. If possible, you should specify the type the forward ref is going to forward to. */
-    typeHint?: ForwardRefTypeHint;
-};
-export type ForwardRef<T extends object = object> = T & {
-    [isForwardRef]: true;
-};
-export declare const ForwardRef: {
-    create<T extends object>(options?: ForwardRefOptions<T>): ForwardRef<T>;
-    isForwardRef<T extends object = object>(value: any): value is ForwardRef<T>;
-    hasRef<T extends object>(forwardRef: ForwardRef<T> | T): boolean;
-    deref<T extends object>(forwardRef: ForwardRef<T> | T): T;
-    tryDeref<T extends object>(forwardRef: ForwardRef<T> | T): T | undefined;
-    setRef<T extends object>(forwardRef: ForwardRef<T> | T, reference: T | undefined): void;
-};
-export {};

package/types/utils/object/lazy-property.d.ts

@@ -1,49 +0,0 @@
-import type { Function, IfUnknown } from '../../../types.js';
-declare const lazyObjectValueSymbol: unique symbol;
-export type LazyPropertyInitializer<T, K extends keyof T> = (this: T, key: K) => T[K];
-export type LazyPropertyObjectDefinition<T extends object, P extends keyof T> = LazyPropertyDescriptor & {
-    /** Define property with existing value */
-    value?: T[P];
-    /** Define property with getter */
-    get?: (this: T) => T[P];
-    /** Define property with setter */
-    set?: (this: T, value: T[P]) => void;
-    /** Lazily define property with initializer */
-    initializer?: LazyPropertyInitializer<T, P>;
-};
-export type LazyObjectValue<T> = {
-    [lazyObjectValueSymbol]: typeof lazyObjectValueSymbol;
-    value: T;
-};
-export type LazyInitializerItem<T extends object, P extends keyof T> = Exclude<IfUnknown<T[P], never, T[P]>, Function | object> | LazyPropertyInitializer<T, P> | LazyPropertyObjectDefinition<T, P> | LazyObjectValue<T[P]>;
-export type LazyPropertyDescriptor = {
-    /**
-     * True if the type of this property descriptor may be changed and if the property may be deleted from the corresponding object
-     * @default true
-     */
-    configurable?: boolean;
-    /**
-     * True if and only if this property shows up during enumeration of the properties on the corresponding object
-     * @default true
-     */
-    enumerable?: boolean;
-    /**
-     * True if the value associated with the property may be changed with an assignment operator
-     * @default true
-     */
-    writable?: boolean;
-};
-/**
- *
- * @param object object to define lazy property on
- * @param propertyKey property key
- * @param initializer
- * @param descriptor
- */
-export declare function lazyProperty<T extends object, K extends keyof T>(object: T, propertyKey: K, initializer: LazyPropertyInitializer<T, K>, descriptor?: LazyPropertyDescriptor): void;
-export declare function lazyObject<T extends object>(initializers: {
-    [P in keyof T]: LazyInitializerItem<T, P>;
-}): T;
-export declare function lazyObjectValue<T>(value: T): LazyObjectValue<T>;
-export declare function isLazyObjectValue<T>(value: any): value is LazyObjectValue<T>;
-export {};

package/types/utils/object/object.d.ts

@@ -1,30 +0,0 @@
-import { type JsonPathInput } from '../../../json-path/json-path.js';
-import type { BaseType, FromEntries, ObjectLiteral, Optionalize, PickBy, Record, SimplifyObject, UnionToIntersection } from '../../../types.js';
-export declare function hasOwnProperty<T extends Record, K extends keyof UnionToIntersection<T>>(obj: T, key: K): obj is Extract<T, Partial<Record<K>>>;
-export declare function hasOwnProperty<T extends Record>(obj: T, key: keyof T): boolean;
-/**
- * Returns object entries including those with symbols keys (which Object.entries does not)
- */
-export declare function objectEntries<T extends ObjectLiteral>(object: T): [keyof T, T[keyof T]][];
-/**
- * Returns object keys including symbols (which Object.keys does not)
- */
-export declare function objectKeys<T extends ObjectLiteral>(object: T): (keyof T)[];
-export declare function objectValues<T extends ObjectLiteral>(object: T): (T[keyof T])[];
-export declare function fromEntries<A>(entries: A): FromEntries<A>;
-export declare function fromEntries<K extends PropertyKey, T>(entries: Iterable<readonly [K, T]>): Record<K, T>;
-export declare function mapObject<T extends ObjectLiteral, K extends string | number | symbol, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => [key: K, value: V]): Record<K, V>;
-export declare function mapObjectAsync<T extends ObjectLiteral, K extends string | number | symbol, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => Promise<[key: K, value: V]>): Promise<Record<K, V>>;
-export declare function mapObjectValues<T extends ObjectLiteral, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => V): Record<keyof T, V>;
-export declare function mapObjectValuesAsync<T extends ObjectLiteral, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => Promise<V>): Promise<Record<keyof T, V>>;
-export declare function filterObject<T extends ObjectLiteral, U extends T[keyof T]>(object: T, predicate: (value: T[keyof T], key: keyof T) => value is U): PickBy<T, U>;
-export declare function filterObject<T extends ObjectLiteral>(object: T, predicate: (value: T[keyof T], key: keyof T) => boolean): Partial<T>;
-export declare function filterObjectAsync<T extends ObjectLiteral>(object: T, predicate: (value: T[keyof T], key: keyof T) => Promise<boolean>): Promise<Partial<T>>;
-export declare function filterUndefinedFromRecord<K extends PropertyKey, V>(record: Record<K, V>): Record<BaseType<K>, Exclude<V, undefined>>;
-export declare function filterUndefinedObjectProperties<T extends ObjectLiteral>(object: T): SimplifyObject<Optionalize<T>>;
-export declare function copyObjectProperties<T extends ObjectLiteral>(source: T, target: T): void;
-export declare function getGetter<T extends ObjectLiteral, U extends keyof T>(obj: T, property: U, bind: boolean): () => T[U];
-export declare function deepObjectEntries(object: ObjectLiteral, keepInnerObjects?: boolean, prefix?: string): [string, any][];
-export declare function fromDeepObjectEntries(entries: readonly (readonly [JsonPathInput, any])[]): ObjectLiteral;
-export declare function omit<T extends Record, K extends keyof T>(object: T, ...keys: K[]): SimplifyObject<Omit<T, K>>;
-export declare function pick<T extends Record, K extends keyof T>(object: T, ...keys: K[]): SimplifyObject<Pick<T, K>>;

package/types/utils/object/property-name.d.ts

@@ -1,61 +0,0 @@
-import type { DeepFlatten, DeepNonNullable, Record } from '../../../types.js';
-export declare const propertyName: unique symbol;
-export declare const cast: unique symbol;
-export type PropertyName = {
-    [propertyName]: string;
-};
-export type PropertyNameProxy<T extends Record> = {
-    [P in keyof DeepNonNullable<T>]: PropertyNameProxyChild<T[P]>;
-};
-export type PropertyNameProxyChild<T> = (T extends Record ? (PropertyNameProxy<T> & PropertyName) : (PropertyName)) & {
-    [cast]<U extends T>(): PropertyNameProxyChild<U>;
-};
-export type PropertyNameOfExpressionObject<T> = {
-    [P in keyof T]: PropertyNameOfExpressionObject<DeepNonNullable<T>[P]> & {
-        [cast]<U extends T[P]>(): PropertyNameOfExpressionObject<DeepNonNullable<U>>;
-    };
-};
-export type FlatPropertyNameOfExpressionObject<T> = {
-    [P in keyof DeepFlatten<T>]: FlatPropertyNameOfExpressionObject<DeepFlatten<DeepNonNullable<T>>[P]> & {
-        [cast]<U extends DeepFlatten<T>[P]>(): FlatPropertyNameOfExpressionObject<DeepNonNullable<U>>;
-    };
-};
-export declare function getPropertyName(name: string): PropertyName;
-export declare function isPropertyName(value: any): value is PropertyName;
-/**
- * Get the path to a property
- *
- * @param options.deep Whether to return the whole path to the property or just the last property
- * @param options.flat Ignore array accesses (properties consiting only of numbers)
- * @param options.prefix Name prefix
- *
- * @example
- * import { getPropertyNameProxy, propertyName } from '@tstdl/base/utils/object.js';
- *
- * const name = getPropertyNameProxy<MyType>().foo.bar[propertyName];
- *
- * name == 'foo.bar' // true
- */
-export declare function getPropertyNameProxy<T extends Record = Record>(options?: {
-    deep?: boolean;
-    flat?: boolean;
-    prefix?: string;
-}): PropertyNameProxy<T>;
-/**
- * Get the path to a property
- * @param expression Property selection expression
- * @param options.deep Whether to return the whole path to the property or just the last property
- * @returns Property name
- */
-export declare function propertyNameOf<T extends Record = Record>(expression: (instance: PropertyNameOfExpressionObject<T>) => any, options?: {
-    deep?: boolean;
-}): string;
-/**
- * Get the flat path to a property (flat = ignore array accesses (properties only consisting of numbers))
- * @param expression Property selection expression
- * @param options.deep Whether to return the whole path to the property or just the last property
- * @returns Property name
- */
-export declare function flatPropertyNameOf<T extends Record = Record>(expression: (instance: FlatPropertyNameOfExpressionObject<T>) => any, options?: {
-    deep?: boolean;
-}): string;

package/types/utils/patch-worker.d.ts

@@ -1,25 +0,0 @@
-import { type Observable } from 'rxjs';
-import type { Record, StringMap } from '../../types.js';
-export type PatchWorkerOptions<T extends StringMap> = {
-    debounceTime?: number;
-    retryDelay?: number;
-    handleOn?: Observable<any>;
-    completeOn?: Observable<any>;
-    handler(patch: Partial<T>): void | Promise<void>;
-    errorHandler?(error: Error): void | Promise<void>;
-};
-export declare class PatchWorker<T extends Record> {
-    private readonly patchAddedSubject;
-    private readonly handleSubject;
-    private readonly completeToken;
-    private readonly options;
-    private patch;
-    constructor(options: PatchWorkerOptions<T>);
-    handleOn(observable: Observable<any>): void;
-    completeOn(observable: Observable<any>): void;
-    add(patch: Partial<T>): void;
-    add<P extends keyof T>(key: P, value: T[P]): void;
-    handle(): void;
-    complete(): void;
-    private handleLoop;
-}