@turndown/library 0.1.16 → 0.1.20

package/dist/helpers/date/index.d.ts

@@ -0,0 +1,113 @@
+export type TDateInput = Date | string | number | null | undefined;
+export type TDateFormat = "MM/DD/YYYY" | "MM/DD/YY HH:mm A" | string;
+/**
+ * Format a date using a dayjs format string.
+ *
+ * @param {TDateInput} date - Date-like value to format.
+ * @param {TDateFormat} format - dayjs format string.
+ * @returns {string} Formatted date or `--` for missing/invalid input.
+ */
+export declare const formatDate: (date?: TDateInput, format?: TDateFormat) => string;
+/**
+ * Return a human-readable relative time string.
+ *
+ * @param {TDateInput} date - Date-like value to compare against now.
+ * @returns {string} Relative time or `--` for missing/invalid input.
+ */
+export declare const timeAgo: (date: TDateInput) => string;
+/**
+ * Add days to a date.
+ *
+ * @param {TDateInput} date - Source date.
+ * @param {number} days - Number of days to add.
+ * @returns {Date} Updated date.
+ */
+export declare const addDays: (date: TDateInput, days: number) => Date;
+/**
+ * Subtract days from a date.
+ *
+ * @param {TDateInput} date - Source date.
+ * @param {number} days - Number of days to subtract.
+ * @returns {Date} Updated date.
+ */
+export declare const subtractDays: (date: TDateInput, days: number) => Date;
+/**
+ * Return the absolute number of whole day boundaries between two dates.
+ *
+ * @param {TDateInput} dateA - First date.
+ * @param {TDateInput} dateB - Second date.
+ * @returns {number} Absolute difference in days, or 0 for invalid input.
+ */
+export declare const daysBetween: (dateA: TDateInput, dateB: TDateInput) => number;
+/**
+ * Check whether a date is today.
+ *
+ * @param {TDateInput} date - Date-like value.
+ * @returns {boolean} True when the date is today.
+ */
+export declare const isToday: (date: TDateInput) => boolean;
+/**
+ * Check whether a date is in the past.
+ *
+ * @param {TDateInput} date - Date-like value.
+ * @returns {boolean} True when the date is before now.
+ */
+export declare const isPast: (date: TDateInput) => boolean;
+/**
+ * Check whether a date is in the future.
+ *
+ * @param {TDateInput} date - Date-like value.
+ * @returns {boolean} True when the date is after now.
+ */
+export declare const isFuture: (date: TDateInput) => boolean;
+/**
+ * Return the start of the day for a date.
+ *
+ * @param {TDateInput} date - Source date.
+ * @returns {Date} Date set to 00:00:00.000.
+ */
+export declare const startOfDay: (date: TDateInput) => Date;
+/**
+ * Return the end of the day for a date.
+ *
+ * @param {TDateInput} date - Source date.
+ * @returns {Date} Date set to 23:59:59.999.
+ */
+export declare const endOfDay: (date: TDateInput) => Date;
+/**
+ * Return the ISO week start date, Monday at 00:00:00.000.
+ *
+ * @param {TDateInput} date - Source date.
+ * @returns {Date} Start of ISO week.
+ */
+export declare const startOfWeek: (date: TDateInput) => Date;
+/**
+ * Return the ISO week end date, Sunday at 23:59:59.999.
+ *
+ * @param {TDateInput} date - Source date.
+ * @returns {Date} End of ISO week.
+ */
+export declare const endOfWeek: (date: TDateInput) => Date;
+/**
+ * Return all seven dates in the ISO week containing the provided date.
+ *
+ * @param {TDateInput} date - Source date.
+ * @returns {Date[]} Monday-through-Sunday dates at the start of each day.
+ */
+export declare const getWeekDays: (date: TDateInput) => Date[];
+/**
+ * Add weeks to a date.
+ *
+ * @param {TDateInput} date - Source date.
+ * @param {number} weeks - Number of weeks to add.
+ * @returns {Date} Updated date.
+ */
+export declare const addWeeks: (date: TDateInput, weeks: number) => Date;
+/**
+ * Subtract weeks from a date.
+ *
+ * @param {TDateInput} date - Source date.
+ * @param {number} weeks - Number of weeks to subtract.
+ * @returns {Date} Updated date.
+ */
+export declare const subtractWeeks: (date: TDateInput, weeks: number) => Date;

package/dist/helpers/date/index.js

@@ -0,0 +1,171 @@
+import dayjs from "dayjs";
+import isoWeek from "dayjs/plugin/isoWeek";
+import relativeTime from "dayjs/plugin/relativeTime";
+dayjs.extend(relativeTime);
+dayjs.extend(isoWeek);
+const defaultDateFallback = "--";
+const isValidDateInput = (date) => {
+    return date !== null && date !== undefined && dayjs(date).isValid();
+};
+/**
+ * Format a date using a dayjs format string.
+ *
+ * @param {TDateInput} date - Date-like value to format.
+ * @param {TDateFormat} format - dayjs format string.
+ * @returns {string} Formatted date or `--` for missing/invalid input.
+ */
+export const formatDate = (date, format = "MM/DD/YYYY") => {
+    if (!isValidDateInput(date)) {
+        return defaultDateFallback;
+    }
+    return dayjs(date).format(format);
+};
+/**
+ * Return a human-readable relative time string.
+ *
+ * @param {TDateInput} date - Date-like value to compare against now.
+ * @returns {string} Relative time or `--` for missing/invalid input.
+ */
+export const timeAgo = (date) => {
+    if (!isValidDateInput(date)) {
+        return defaultDateFallback;
+    }
+    return dayjs(date).fromNow();
+};
+/**
+ * Add days to a date.
+ *
+ * @param {TDateInput} date - Source date.
+ * @param {number} days - Number of days to add.
+ * @returns {Date} Updated date.
+ */
+export const addDays = (date, days) => {
+    return dayjs(date).add(days, "day").toDate();
+};
+/**
+ * Subtract days from a date.
+ *
+ * @param {TDateInput} date - Source date.
+ * @param {number} days - Number of days to subtract.
+ * @returns {Date} Updated date.
+ */
+export const subtractDays = (date, days) => {
+    return dayjs(date).subtract(days, "day").toDate();
+};
+/**
+ * Return the absolute number of whole day boundaries between two dates.
+ *
+ * @param {TDateInput} dateA - First date.
+ * @param {TDateInput} dateB - Second date.
+ * @returns {number} Absolute difference in days, or 0 for invalid input.
+ */
+export const daysBetween = (dateA, dateB) => {
+    if (!isValidDateInput(dateA) || !isValidDateInput(dateB)) {
+        return 0;
+    }
+    return Math.abs(dayjs(dateA).diff(dayjs(dateB), "day"));
+};
+/**
+ * Check whether a date is today.
+ *
+ * @param {TDateInput} date - Date-like value.
+ * @returns {boolean} True when the date is today.
+ */
+export const isToday = (date) => {
+    if (!isValidDateInput(date)) {
+        return false;
+    }
+    return dayjs(date).isSame(dayjs(), "day");
+};
+/**
+ * Check whether a date is in the past.
+ *
+ * @param {TDateInput} date - Date-like value.
+ * @returns {boolean} True when the date is before now.
+ */
+export const isPast = (date) => {
+    if (!isValidDateInput(date)) {
+        return false;
+    }
+    return dayjs(date).isBefore(dayjs());
+};
+/**
+ * Check whether a date is in the future.
+ *
+ * @param {TDateInput} date - Date-like value.
+ * @returns {boolean} True when the date is after now.
+ */
+export const isFuture = (date) => {
+    if (!isValidDateInput(date)) {
+        return false;
+    }
+    return dayjs(date).isAfter(dayjs());
+};
+/**
+ * Return the start of the day for a date.
+ *
+ * @param {TDateInput} date - Source date.
+ * @returns {Date} Date set to 00:00:00.000.
+ */
+export const startOfDay = (date) => {
+    return dayjs(date).startOf("day").toDate();
+};
+/**
+ * Return the end of the day for a date.
+ *
+ * @param {TDateInput} date - Source date.
+ * @returns {Date} Date set to 23:59:59.999.
+ */
+export const endOfDay = (date) => {
+    return dayjs(date).endOf("day").toDate();
+};
+/**
+ * Return the ISO week start date, Monday at 00:00:00.000.
+ *
+ * @param {TDateInput} date - Source date.
+ * @returns {Date} Start of ISO week.
+ */
+export const startOfWeek = (date) => {
+    return dayjs(date).startOf("isoWeek").toDate();
+};
+/**
+ * Return the ISO week end date, Sunday at 23:59:59.999.
+ *
+ * @param {TDateInput} date - Source date.
+ * @returns {Date} End of ISO week.
+ */
+export const endOfWeek = (date) => {
+    return dayjs(date).endOf("isoWeek").toDate();
+};
+/**
+ * Return all seven dates in the ISO week containing the provided date.
+ *
+ * @param {TDateInput} date - Source date.
+ * @returns {Date[]} Monday-through-Sunday dates at the start of each day.
+ */
+export const getWeekDays = (date) => {
+    const weekStart = dayjs(date).startOf("isoWeek");
+    return Array.from({ length: 7 }, (_value, index) => {
+        return weekStart.add(index, "day").startOf("day").toDate();
+    });
+};
+/**
+ * Add weeks to a date.
+ *
+ * @param {TDateInput} date - Source date.
+ * @param {number} weeks - Number of weeks to add.
+ * @returns {Date} Updated date.
+ */
+export const addWeeks = (date, weeks) => {
+    return dayjs(date).add(weeks, "week").toDate();
+};
+/**
+ * Subtract weeks from a date.
+ *
+ * @param {TDateInput} date - Source date.
+ * @param {number} weeks - Number of weeks to subtract.
+ * @returns {Date} Updated date.
+ */
+export const subtractWeeks = (date, weeks) => {
+    return dayjs(date).subtract(weeks, "week").toDate();
+};

package/dist/helpers/index.d.ts

@@ -1,2 +1,4 @@
+export * from "./date";
 export * from "./object";
-export * from "./string";
+export { camelCase, capitalize, charCount, containsAll, containsAny, escapeRegex, extractNumbers, formatAddress, fromBase64, highlight, isEmail, isEmpty, isNumeric, isPalindrome, isUrl, kebabCase, kebabToSpaces, longestWord, lowerCase, normalCase, normalizeSpaces, padEnd, padStart, pascalCase, pluralize, removeDuplicates, removeSpecialChars, removeWhitespace, repeat, repeatChar, reverse, sentenceCase, slug, snakeCase, snakeCaseToSpaces, splitMultiple, stringSimilarity, stripHtml, titleCase, toBase64, toCamelCase, toKebabCase, toNumber, toPascalCase, toSnakeCase, truncate, upperCase, wordCount, } from "./string";
+export type { IAddress } from "./string";

package/dist/helpers/index.js

@@ -1,2 +1,3 @@
+export * from "./date";
 export * from "./object";
-export * from "./string";
+export { camelCase, capitalize, charCount, containsAll, containsAny, escapeRegex, extractNumbers, formatAddress, fromBase64, highlight, isEmail, isEmpty, isNumeric, isPalindrome, isUrl, kebabCase, kebabToSpaces, longestWord, lowerCase, normalCase, normalizeSpaces, padEnd, padStart, pascalCase, pluralize, removeDuplicates, removeSpecialChars, removeWhitespace, repeat, repeatChar, reverse, sentenceCase, slug, snakeCase, snakeCaseToSpaces, splitMultiple, stringSimilarity, stripHtml, titleCase, toBase64, toCamelCase, toKebabCase, toNumber, toPascalCase, toSnakeCase, truncate, upperCase, wordCount, } from "./string";

package/dist/helpers/object/index.d.ts

@@ -1,52 +1,62 @@
-import { FilterCondition, SortCondition, TurndownObject } from "../../index";
-export interface Version {
-    major: number;
-    minor: number;
-    patch: number;
-}
-export type VersionInput = string | Version;
+import type { IFilterCondition, ISortCondition } from "../../types/base/paging.types";
+type TRecord = Record<string, unknown>;
+type TSortableValue = string | number | bigint | boolean | Date | null | undefined;
+type TReplaceNulls<TValue> = TValue extends null ? "" : TValue extends (infer TItem)[] ? TReplaceNulls<TItem>[] : TValue extends Date ? TValue : TValue extends object ? {
+    [TKey in keyof TValue]: TReplaceNulls<TValue[TKey]>;
+} : TValue;
 /**
- * Safely parse a JSON string into a value.
+ * Safely parse a JSON string into a typed value.
  *
- * Returns `{}` if parsing fails instead of throwing.
+ * When a fallback value is provided, the function always returns that generic
+ * type. Without a fallback value, parse failures return an empty object.
  *
- * @param {TurndownObject} jsonString - The JSON string to parse.
- * @returns {TurndownObject} Parsed value or `{}` on failure.
+ * @typeParam TParsed - Expected parsed value type.
+ * @param {string | null | undefined} jsonString - JSON string to parse.
+ * @param {TParsed} [fallbackValue] - Value returned when parsing fails.
+ * @returns {TParsed | Record<string, unknown>} Parsed value or fallback.
  * @example
- * parseJSON('{"a":1}') // => { a: 1 }
+ * parseJSON<{ a: number }>('{"a":1}', { a: 0 }) // => { a: 1 }
  * parseJSON('not json') // => {}
  */
-export declare const parseJSON: (jsonString: TurndownObject) => TurndownObject;
+export declare function parseJSON<TParsed>(jsonString: string | null | undefined, fallbackValue: TParsed): TParsed;
+export declare function parseJSON(jsonString: string | null | undefined): Record<string, unknown>;
 /**
- * Stringify an object to JSON while skipping circular references.
+ * Stringify a value to JSON while skipping circular references.
  *
  * Uses an internal cache to omit repeated object references that would
  * normally cause `JSON.stringify` to throw.
  *
- * @param {TurndownObject} obj - Value to stringify.
- * @returns {string} JSON string with circulars omitted.
+ * @param {unknown} value - Value to stringify.
+ * @returns {string | undefined} JSON string with circulars omitted.
  * @example
- * const a:any = {}; a.self = a;
- * JSONStringify(a) // => "{}"
+ * const value: Record<string, unknown> = {}; value.self = value;
+ * JSONStringify(value) // => "{}"
  */
-export declare const JSONStringify: (obj: TurndownObject) => string;
+export declare const JSONStringify: (value: unknown) => string | undefined;
 /**
- * Deep-remove `undefined` properties by serializing & parsing.
+ * Deep-remove `undefined` properties while preserving Dates and arrays.
  *
- * @param {TurndownObject} obj - Input object.
- * @returns {TurndownObject} Cleaned clone with `undefined` removed.
+ * Object properties with `undefined` values are removed. Array items are
+ * preserved so array indexes do not shift.
+ *
+ * @typeParam TValue - Input value type.
+ * @param {TValue} value - Input value.
+ * @returns {TValue} Cleaned clone with `undefined` object properties removed.
  */
-export declare const removeUndefined: (obj: TurndownObject) => TurndownObject;
+export declare const removeUndefined: <TValue>(value: TValue) => TValue;
 /**
  * Test whether a location object's `pathname` equals a key.
  *
- * @param {TurndownObject} location - Object expected to have a `pathname`.
+ * @param {{ pathname?: string } | null | undefined} location - Object expected
+ * to have a `pathname`.
  * @param {string} key - Path to compare.
  * @returns {boolean}
  * @example
  * validPath({ pathname: "/home" }, "/home") // true
  */
-export declare const validPath: (location: TurndownObject, key: string) => boolean;
+export declare const validPath: (location: {
+    pathname?: string;
+} | null | undefined, key: string) => boolean;
 /**
  * Return the first element if the input is an array; otherwise return the value itself.
  *
@@ -64,7 +74,7 @@ export declare const returnObject: <T>(input: T | T[]) => T;
  * @typeParam T - Object type with an `id` field.
  * @param {T[]} [array1] - Source array.
  * @param {T[]} [array2] - Items whose `id`s should be excluded.
- * @returns {T[]} Filtered array (or `[]` on errors/invalid input).
+ * @returns {T[]} Filtered array (or `[]` on invalid input).
  */
 export declare const filterArrayById: <T extends {
     id: number | string;
@@ -75,68 +85,72 @@ export declare const filterArrayById: <T extends {
  * Mutates the original array (uses `Array.prototype.sort`).
  *
  * @typeParam T - Object type.
+ * @typeParam TKey - Sortable property key.
  * @param {T[]} array - Array to sort.
- * @param {keyof T} property - Property name to sort by.
+ * @param {TKey} property - Property name to sort by.
  * @returns {T[]} The same array instance, sorted (or empty array if input invalid).
  */
-export declare const sortArrayByProperty: <T extends Record<string, any>>(array: T[], property: keyof T) => T[];
+export declare const sortArrayByProperty: <TKey extends PropertyKey, T extends Record<TKey, TSortableValue>>(array: T[], property: TKey) => T[];
 /**
  * Recursively replace `null` values with empty strings.
  *
- * Works on primitives, arrays, and plain objects.
+ * Works on primitives, arrays, Dates, and plain objects.
  *
- * @param {TurndownObject} obj - Input value.
- * @returns {TurndownObject} Value with all `null` replaced by `""`.
+ * @typeParam TValue - Input value type.
+ * @param {TValue} value - Input value.
+ * @returns {TReplaceNulls<TValue>} Value with all `null` replaced by `""`.
  */
-export declare const replaceNulls: (obj: TurndownObject) => TurndownObject;
+export declare const replaceNulls: <TValue>(value: TValue) => TReplaceNulls<TValue>;
 /**
  * Recursively remove object keys that contain a dot (`.`).
  *
- * @typeParam T - Object type.
- * @param {T} obj - Input object.
- * @returns {T} New object with dotted keys removed at all levels.
+ * @typeParam TValue - Input value type.
+ * @param {TValue} value - Input object or array.
+ * @returns {TValue} New value with dotted keys removed at all levels.
  */
-export declare const removeFormProperties: <T extends Record<string, TurndownObject>>(obj: T) => T;
+export declare const removeFormProperties: <TValue>(value: TValue) => TValue;
 /**
  * Recursively convert string booleans `"true"`/`"false"` to actual booleans.
  *
  * Leaves all other values unchanged.
  *
- * @typeParam T - Object type.
- * @param {T} obj - Input object or array.
- * @returns {T} New value with boolean-like strings converted.
+ * @typeParam TValue - Input value type.
+ * @param {TValue} value - Input object or array.
+ * @returns {TValue} New value with boolean-like strings converted.
  */
-export declare const convertStringBooleans: <T extends Record<string, any>>(obj: T) => T;
+export declare const convertStringBooleans: <TValue>(value: TValue) => TValue;
 /**
  * Convenience helper to clean form-like data:
  * - Removes `undefined` properties
  * - Converts string booleans to booleans
- * - Removes keys containing a dot ('.')
+ * - Removes keys containing a dot (`.`)
  *
- * @param {TurndownObject} obj - Input data.
- * @returns {TurndownObject} Cleaned clone.
+ * @typeParam TObject - Form data object type.
+ * @param {TObject} objectToClean - Input data.
+ * @returns {Partial<TObject>} Cleaned clone.
  */
-export declare const cleanFormData: (obj: TurndownObject) => any;
+export declare const cleanFormData: <TObject extends TRecord>(objectToClean: TObject) => Partial<TObject>;
 /**
  * Return a default pagination object, allowing optional sort and filters.
  *
- * @param {SortCondition[]} [sort] - Optional sort conditions.
- * @param {FilterCondition[]} [filters] - Optional filter conditions.
- * @returns {{ page: number; size: number; sort: SortCondition[]; filters: FilterCondition[] }}
+ * @param {ISortCondition[]} [sort] - Optional sort conditions.
+ * @param {IFilterCondition[]} [filters] - Optional filter conditions.
+ * @returns {{ page: number; size: number; sort: ISortCondition[]; filters: IFilterCondition[] }}
  * @example
  * resetPagination() // => { page:1, size:25, sort:[], filters:[] }
  */
-export declare const resetPagination: (sort?: SortCondition[], filters?: FilterCondition[]) => {
+export declare const resetPagination: (sort?: ISortCondition[], filters?: IFilterCondition[]) => {
     page: number;
     size: number;
-    sort: SortCondition[];
-    filters: FilterCondition[];
+    sort: ISortCondition[];
+    filters: IFilterCondition[];
 };
 /**
  * Format a string of digits into a U.S. phone number.
  *
- * Strips non-numeric characters and formats as `(XXX) XXX-XXXX`.
- * If fewer than 10 digits are provided, returns the input unchanged.
+ * Strips non-numeric characters and formats 10 digits as `(XXX) XXX-XXXX`.
+ * Strips a leading US country code when 11 digits are provided.
+ * If a value cannot be formatted, returns the original value as a string.
  *
  * @param {string | number} value - Phone number digits (string or number).
  * @returns {string} Formatted phone number, or original input if invalid length.
@@ -156,58 +170,129 @@ export declare const formatPhoneNumber: (value: string | number) => string;
  */
 export declare const formatNumber: (value: number) => string;
 /**
- * Parse a number string (note: current implementation adds commas as well).
+ * Remove comma separators from a number-like value.
  *
- * @remarks
- * This function uses the same regex as `formatNumber`, so it **does not remove**
- * commas; it inserts them. If you intended to *strip* separators, consider:
- * `value.toString().replace(/,/g, "")`.
- *
- * @param {number} value - Number to "parse".
- * @returns {string} Currently returns a comma-formatted string.
+ * @param {number | string} value - Number-like value.
+ * @returns {string} Value without comma separators.
  */
-export declare const parseNumber: (value: number) => string;
+export declare const parseNumber: (value: number | string) => string;
 /**
  * Delete a property from an object if it exists (no-op if it doesn't).
  *
- * @param {TurndownObject} obj - Target object (mutated).
- * @param {string} propertyName - Property to delete.
+ * @typeParam TObject - Object type.
+ * @param {TObject} objectToUpdate - Target object (mutated).
+ * @param {keyof TObject | string} propertyName - Property to delete.
  * @returns {void}
  */
-export declare const deletePropertyIfExists: (obj: TurndownObject, propertyName: string) => void;
+export declare const deletePropertyIfExists: <TObject extends TRecord>(objectToUpdate: TObject, propertyName: keyof TObject | string) => void;
 /**
  * Split an array into chunks of a given size.
  *
  * @typeParam T - Element type.
  * @param {T[]} array - Source array.
- * @param {number} chunkSize - Size of each chunk (no validation performed).
+ * @param {number} chunkSize - Size of each chunk.
  * @returns {T[][]} Array of chunks (last one may be smaller).
  * @example
  * chunkArray([1,2,3,4,5], 2) // [[1,2],[3,4],[5]]
  */
 export declare const chunkArray: <T>(array: T[], chunkSize: number) => T[][];
 /**
- * Return a shallow clone of `obj` without the listed properties.
+ * Return a shallow clone of `objectToOmitFrom` without the listed properties.
  *
- * @param {TurndownObject} obj - Source object.
- * @param {TurndownObject} propsToOmit - Iterable of property names (expects array-like).
- * @returns {TurndownObject} New object without omitted props.
+ * @typeParam TObject - Source object type.
+ * @typeParam TKey - Keys to omit.
+ * @param {TObject} objectToOmitFrom - Source object.
+ * @param {readonly TKey[]} propsToOmit - Property names to omit.
+ * @returns {Omit<TObject, TKey>} New object without omitted props.
  * @example
  * omitProperties({a:1,b:2}, ["b"]) // { a:1 }
  */
-export declare const omitProperties: (obj: TurndownObject, propsToOmit: TurndownObject) => any;
+export declare const omitProperties: <TObject extends TRecord, TKey extends keyof TObject>(objectToOmitFrom: TObject, propsToOmit: readonly TKey[]) => Omit<TObject, TKey>;
 /**
  * Safe `hasOwnProperty` check.
  *
- * @param {Record<string, any>} obj - Object to test.
- * @param {string} key - Property name.
+ * @param {unknown} value - Value to test.
+ * @param {PropertyKey} key - Property name.
  * @returns {boolean}
  */
-export declare const hasProperty: (obj: Record<string, any>, key: string) => boolean;
+export declare const hasProperty: <TKey extends PropertyKey>(value: unknown, key: TKey) => value is Record<TKey, unknown>;
+/**
+ * Safe `hasOwnProperty` alias from the reference utilities.
+ *
+ * @param {unknown} value - Value to test.
+ * @param {PropertyKey} key - Property name.
+ * @returns {boolean}
+ */
+export declare const hasOwnProp: <TKey extends PropertyKey>(value: unknown, key: TKey) => value is Record<TKey, unknown>;
 /**
  * Determine if an object has at least one own enumerable property.
  *
- * @param {object} obj - Object to test.
+ * @param {unknown} value - Object to test.
  * @returns {boolean} `true` if there is at least one key.
  */
-export declare const hasProperties: (obj: object) => boolean;
+export declare const hasProperties: (value: unknown) => boolean;
+/**
+ * Get the first own enumerable property value from an object.
+ *
+ * @typeParam TObject - Source object type.
+ * @param {TObject | null | undefined} value - Source object.
+ * @returns {TObject[keyof TObject] | null} First value, or null for empty/non-object input.
+ */
+export declare const getFirstPropertyValue: <TObject extends TRecord>(value: TObject | null | undefined) => TObject[keyof TObject] | null;
+/**
+ * Get a nested value from an object using dot notation.
+ *
+ * @param {unknown} value - Source object.
+ * @param {string} path - Dot-delimited path.
+ * @returns {unknown} Nested value, or undefined when the path cannot be resolved.
+ * @example
+ * getNestedValue({ user: { name: "John" } }, "user.name") // "John"
+ */
+export declare const getNestedValue: (value: unknown, path: string) => unknown;
+/**
+ * Set a nested value on an object using dot notation.
+ *
+ * Mutates and returns the provided object. Unsafe path segments are ignored to
+ * prevent prototype pollution.
+ *
+ * @typeParam TObject - Target object type.
+ * @param {TObject} objectToUpdate - Target object.
+ * @param {string} path - Dot-delimited path.
+ * @param {unknown} value - Value to set.
+ * @returns {TObject} The mutated target object.
+ * @example
+ * setNestedValue({}, "user.name", "John") // { user: { name: "John" } }
+ */
+export declare const setNestedValue: <TObject extends TRecord>(objectToUpdate: TObject, path: string, value: unknown) => TObject;
+/**
+ * Deep clone a value while preserving Dates and circular references.
+ *
+ * @typeParam TValue - Input value type.
+ * @param {TValue} value - Value to clone.
+ * @returns {TValue} Deep clone of the input.
+ */
+export declare const deepClone: <TValue>(value: TValue) => TValue;
+/**
+ * Flatten a nested object into dot notation.
+ *
+ * Arrays and Dates are treated as leaf values.
+ *
+ * @param {TRecord} value - Source object.
+ * @param {string} [prefix] - Internal prefix for recursion.
+ * @returns {TRecord} Flattened object.
+ * @example
+ * flatten({ user: { name: "John" } }) // { "user.name": "John" }
+ */
+export declare const flatten: (value: TRecord, prefix?: string) => TRecord;
+/**
+ * Convert a dot-notation object into a nested object.
+ *
+ * Unsafe path segments are ignored to prevent prototype pollution.
+ *
+ * @param {TRecord} value - Dot-notation source object.
+ * @returns {TRecord} Nested object.
+ * @example
+ * unflatten({ "user.name": "John" }) // { user: { name: "John" } }
+ */
+export declare const unflatten: (value: TRecord) => TRecord;
+export {};