@dereekb/util 11.1.8 → 12.0.0

package/src/lib/contact/phone.d.ts

@@ -23,16 +23,19 @@ export type PhoneExtensionNumber = string;
  */
 export type E164PhoneNumber = `+${PhoneNumber}`;
 /**
- * E164PhoneNumber regex validator.
+ * Regular expression for validating E.164 phone numbers.
+ * Validates numbers that start with a + followed by 2-15 digits.
+ * The first digit after the + must be 1-9 (not 0).
  *
  * Requires the + to be provided.
  */
 export declare const E164PHONE_NUMBER_REGEX: RegExp;
 /**
- * Returns true if the input phone number is a valid E164PHONE_NUMBER_REGEX value.
+ * Validates if the input string is a valid E.164 phone number.
  *
- * @param input
- * @returns
+ * @param input - The phone number string to validate
+ * @param allowExtension - If true, allows an extension in the format +number#extension
+ * @returns True if the input is a valid E.164 phone number
  */
 export declare function isE164PhoneNumber(input: string, allowExtension?: boolean): input is E164PhoneNumber;
 /**
@@ -46,39 +49,70 @@ export type E164PhoneNumberWithExtension = `+${PhoneNumber}#${PhoneExtensionNumb
  */
 export type E164PhoneNumberWithOptionalExtension = E164PhoneNumber | E164PhoneNumberWithExtension;
 /**
- * E164PhoneNumber regex validator with an optional extension.
+ * Regular expression for validating E.164 phone numbers with an optional extension.
+ * Validates numbers in the format +number or +number#extension.
+ * The extension part is 1-6 digits following a # character.
  *
  * Requires the + to be provided.
  */
 export declare const E164PHONE_NUMBER_WITH_OPTIONAL_EXTENSION_REGEX: RegExp;
 /**
- * E164PhoneNumber regex validator with an extension.
+ * Regular expression for validating E.164 phone numbers that must include an extension.
+ * Validates numbers strictly in the format +number#extension.
+ * The extension part is 1-6 digits following a # character.
  *
- * Requires the + to be provided.
+ * Requires the + to be provided and the extension part.
  */
 export declare const E164PHONE_NUMBER_WITH_EXTENSION_REGEX: RegExp;
 /**
- * Returns true if the input phone number is a valid E164PHONE_NUMBER_WITH_EXTENSION_REGEX value.
+ * Validates if the input string is a valid E.164 phone number with an extension.
+ * The phone number must be in the format +number#extension.
  *
- * @param input
- * @returns
+ * @param input - The phone number string to validate
+ * @returns True if the input is a valid E.164 phone number with extension
  */
 export declare function isE164PhoneNumberWithExtension(input: string): input is E164PhoneNumberWithExtension;
+/**
+ * Regular expression for validating phone extension numbers.
+ * Extension must be 1-6 digits with no other characters.
+ */
 export declare const PHONE_EXTENSION_NUMBER_REGEX: RegExp;
 /**
- * Returns true if the input is a valid phone number extension.
+ * Validates if the input string is a valid phone extension number.
+ * Valid extensions are 1-6 digits with no other characters.
  *
- * @param input
- * @returns
+ * @param input - The extension string to validate
+ * @returns True if the input is a valid phone extension number
  */
 export declare function isValidPhoneExtensionNumber(input: string): input is PhoneExtensionNumber;
 /**
- * Removes the extension characters from the input phone number.
+ * Removes the extension portion from a phone number.
+ * If the phone number contains a # character, everything after it is removed.
+ *
+ * @param input - The phone number with or without extension
+ * @returns The phone number with any extension removed
  */
 export declare const removeExtensionFromPhoneNumber: (input: PhoneNumber | E164PhoneNumberWithOptionalExtension) => E164PhoneNumber;
+/**
+ * Interface representing a phone number and its optional extension as separate parts.
+ */
 export interface E164PhoneNumberExtensionPair {
     number: E164PhoneNumber;
     extension?: Maybe<PhoneExtensionNumber>;
 }
+/**
+ * Splits a phone number into its main number and extension components.
+ * If the input contains a # character, everything before is the number and everything after is the extension.
+ *
+ * @param input - The phone number string to split
+ * @returns An object containing the number and optional extension
+ */
 export declare function e164PhoneNumberExtensionPair(input: PhoneNumber | E164PhoneNumberWithOptionalExtension): E164PhoneNumberExtensionPair;
+/**
+ * Combines a phone number and optional extension into a single string.
+ * If an extension is provided, it will be appended with a # separator.
+ *
+ * @param input - An object containing the phone number and optional extension
+ * @returns A formatted phone number string with optional extension
+ */
 export declare function e164PhoneNumberFromE164PhoneNumberExtensionPair(input: E164PhoneNumberExtensionPair): E164PhoneNumberWithOptionalExtension;

package/src/lib/date/date.d.ts

@@ -7,6 +7,14 @@ export type DateRelativeDirection = 'past' | 'future';
  * Hour, minute, or second as a string.
  */
 export type DateHourMinuteOrSecond = 'hour' | 'minute' | 'second';
+/**
+ * A valid RFC3339 formatted date string.
+ *
+ * I.E. "2020-04-30 00:00:00.000Z" and "2020-04-30T00:00:00.000Z"
+ *
+ * The only difference between this and an ISO8601DateString is the spacing between the date and time is allowed, while in ISO8601DateString it is not.
+ */
+export type RFC3339DateString = string;
 /**
  * A valid ISO8601 formatted date string.
  *
@@ -14,9 +22,17 @@ export type DateHourMinuteOrSecond = 'hour' | 'minute' | 'second';
  */
 export type ISO8601DateString = string;
 /**
+ * Regular expression for validating ISO8601 date strings.
+ *
  * TODO(FUTURE): Need to improve to support negative years.
  */
 export declare const ISO_8601_DATE_STRING_REGEX: RegExp;
+/**
+ * Determines if a string is a valid ISO8601 date string.
+ *
+ * @param input - The string to test
+ * @returns True if the input is a valid ISO8601 date string
+ */
 export declare function isISO8601DateString(input: string): input is ISO8601DateString;
 /**
  * A UTC date string.
@@ -32,6 +48,12 @@ export type UTCDateString = string;
  * Wed, 25 May 2024 20:45:07 EST
  */
 export declare const UTC_DATE_STRING_REGEX: RegExp;
+/**
+ * Determines if a string is a valid UTC date string.
+ *
+ * @param input - The string to test
+ * @returns True if the input is a valid UTC date string
+ */
 export declare function isUTCDateString(input: string): boolean;
 /**
  * A full ISO8601 date string that is in UTC.
@@ -58,9 +80,9 @@ export interface TimezoneStringRef {
 /**
  * Returns true only if the inputs have the same timezone, or both do not have a timezone set.
  *
- * @param a
- * @param b
- * @returns
+ * @param a - First object that may contain a timezone reference
+ * @param b - Second object that may contain a timezone reference
+ * @returns True if both objects have the same timezone or neither has a timezone set
  */
 export declare function hasSameTimezone(a: Maybe<Partial<TimezoneStringRef>>, b: Maybe<Partial<TimezoneStringRef>>): boolean;
 /**
@@ -72,10 +94,11 @@ export declare const UTC_TIMEZONE_STRING = "UTC";
  */
 export type UTCTimezoneAbbreviation = typeof UTC_TIMEZONE_STRING;
 /**
- * Whether or not the input timezone string is considered UTC.
+ * Determines whether the input timezone string is considered UTC.
+ * Returns true for null, undefined, or the string 'UTC'.
  *
- * @param timezone
- * @returns
+ * @param timezone - The timezone string to check
+ * @returns True if the timezone is considered UTC
  */
 export declare function isConsideredUtcTimezoneString(timezone: Maybe<TimezoneString>): boolean;
 export declare function isConsideredUtcTimezoneString(timezone: TimezoneString): boolean;
@@ -138,7 +161,19 @@ export declare function parseISO8601DayStringToUTCDate(inputDateString: ISO8601D
  * @param input
  * @returns
  */
+/**
+ * Determines if a string is a valid ISO8601 day string (YYYY-MM-DD format).
+ *
+ * @param input - The string to test
+ * @returns True if the input is a valid ISO8601 day string
+ */
 export declare function isISO8601DayString(input: string): input is ISO8601DayString;
+/**
+ * Determines if a string starts with a valid ISO8601 day string pattern (YYYY-MM-DD).
+ *
+ * @param input - The string to test
+ * @returns True if the input starts with a valid ISO8601 day string pattern
+ */
 export declare function isISO8601DayStringStart(input: string): input is ISO8601DayString;
 /**
  * Date that is represented by slashes. Is considered in the Month/Day/Year format.
@@ -148,12 +183,20 @@ export type MonthDaySlashDate = string;
  * Regex for a MonthDaySlashDate.
  */
 export declare const MONTH_DAY_SLASH_DATE_STRING_REGEX: RegExp;
+/**
+ * Determines if a string is a valid Month/Day/Year slash date format.
+ *
+ * @param input - The string to test
+ * @returns True if the input is a valid Month/Day/Year slash date
+ */
 export declare function isMonthDaySlashDate(input: string): input is MonthDaySlashDate;
 /**
- * Converts the input MonthDaySlashDate to an ISO8601DayString.
+ * Converts the input MonthDaySlashDate (MM/DD/YYYY) to an ISO8601DayString (YYYY-MM-DD).
+ * Handles single digit months and days by adding leading zeros.
+ * If year is only 2 digits, prepends '20' to make a 4-digit year.
  *
- * @param slashDate
- * @returns
+ * @param slashDate - The slash date string to convert (e.g., '1/1/20' or '11/15/2022')
+ * @returns An ISO8601 formatted day string (YYYY-MM-DD)
  */
 export declare function monthDaySlashDateToDateString(slashDate: MonthDaySlashDate): ISO8601DayString;
 /**
@@ -171,13 +214,37 @@ export type Seconds = number;
 export type Minutes = number;
 export type Hours = number;
 export type Days = number;
+/**
+ * Number of hours in a day.
+ */
 export declare const HOURS_IN_DAY = 24;
+/**
+ * Number of seconds in a minute.
+ */
 export declare const SECONDS_IN_MINUTE = 60;
+/**
+ * Number of minutes in a day.
+ */
 export declare const MINUTES_IN_DAY = 1440;
+/**
+ * Number of minutes in an hour.
+ */
 export declare const MINUTES_IN_HOUR = 60;
+/**
+ * Number of milliseconds in a second.
+ */
 export declare const MS_IN_SECOND = 1000;
+/**
+ * Number of milliseconds in a minute.
+ */
 export declare const MS_IN_MINUTE: number;
+/**
+ * Number of milliseconds in an hour.
+ */
 export declare const MS_IN_HOUR: number;
+/**
+ * Number of milliseconds in a day.
+ */
 export declare const MS_IN_DAY: number;
 /**
  * Day of the month, 1-31
@@ -194,13 +261,26 @@ export type MonthOfYear = number;
  */
 export type DateMonth = number;
 /**
- * Retrieves the MonthOfYear value from the input Date.
+ * Retrieves the MonthOfYear value (1-12) from the input Date.
+ * Converts JavaScript's 0-based month (0-11) to a 1-based month (1-12).
  *
- * @param date
- * @returns
+ * @param date - The date to extract the month from
+ * @returns The month of year as a number from 1-12
  */
 export declare function monthOfYearFromDate(date: Date): MonthOfYear;
+/**
+ * Converts a JavaScript Date month (0-11) to a MonthOfYear (1-12).
+ *
+ * @param dateMonth - JavaScript Date month (0-11)
+ * @returns The month of year as a number from 1-12
+ */
 export declare function monthOfYearFromDateMonth(dateMonth: DateMonth): MonthOfYear;
+/**
+ * Converts a MonthOfYear (1-12) to a JavaScript Date month (0-11).
+ *
+ * @param monthOfYear - Month of year (1-12)
+ * @returns JavaScript Date month (0-11)
+ */
 export declare function makeDateMonthForMonthOfYear(monthOfYear: MonthOfYear): DateMonth;
 /**
  * Year number. I.E. 2022
@@ -211,34 +291,36 @@ export type YearNumber = number;
  */
 export type DateRelativeState = DateRelativeDirection | 'present';
 /**
- * Returns true if the value is a date.
+ * Returns true if the value is a Date object.
+ * Uses both instanceof and Object.prototype.toString for reliable type checking.
  *
- * @param value
- * @returns
+ * @param value - The value to check
+ * @returns True if the value is a Date object
  */
 export declare function isDate(value: unknown): value is Date;
 /**
- * Returns true if the two input dates are equal.
+ * Returns true if the two input dates represent the same point in time.
+ * Compares the timestamp values rather than the object references.
  *
- * @param a
- * @param b
- * @returns
+ * @param a - First date to compare
+ * @param b - Second date to compare
+ * @returns True if the dates represent the same point in time
  */
 export declare function isEqualDate(a: Date, b: Date): boolean;
 /**
- * Returns true if the input date is in the past.
+ * Returns true if the input date is in the past relative to the current time.
  *
- * @param input
- * @returns
+ * @param input - The date to check
+ * @returns True if the date is in the past
  */
 export declare function isPast(input: Date): boolean;
 /**
- * Adds milliseconds to the input date.
- *
- * If no date is input, then returns the input.
+ * Adds milliseconds to the input date, returning a new Date object.
+ * If no date is input, then returns the input unchanged.
  *
- * @param input
- * @param ms
+ * @param input - The date to add milliseconds to
+ * @param ms - The number of milliseconds to add (defaults to 0 if null or undefined)
+ * @returns A new Date with the added milliseconds, or the original input if not a Date
  */
 export declare function addMilliseconds(input: Date, ms: Maybe<Milliseconds>): Date;
 export declare function addMilliseconds(input: MaybeNot, ms: Maybe<Milliseconds>): MaybeNot;

package/src/lib/date/date.time.d.ts

@@ -10,22 +10,45 @@ import { type Maybe } from '../value/maybe.type';
  * - 120
  */
 export type ReadableTimeString = string;
+/**
+ * Enumeration of AM/PM time indicators.
+ */
 export declare enum TimeAM {
     AM = "AM",
     PM = "PM"
 }
+/**
+ * Constant representing the current time/date.
+ * Used in logical date calculations to indicate "now".
+ */
 export declare const DATE_NOW_VALUE = "now";
+/**
+ * Type representing the current date/time value.
+ */
 export type DateNow = typeof DATE_NOW_VALUE;
+/**
+ * String codes that represent logical dates, such as 'now'.
+ */
 export type LogicalDateStringCode = DateNow;
 /**
  * A date that is characterized by either a known string value, or a Date.
  */
 export type LogicalDate = Date | LogicalDateStringCode;
 /**
- * Returns a Date value from the input LogicalDate.
+ * Converts a LogicalDate into an actual Date object.
+ * If the LogicalDate is already a Date, it's returned as is.
+ * If it's a string code like 'now', it's converted to the appropriate Date value.
  *
- * @param logicalDate
+ * @param logicalDate - A LogicalDate value to convert (Date object or string code)
+ * @returns A Date object representing the logical date, or null/undefined if input was null/undefined
  */
 export declare function dateFromLogicalDate(logicalDate: LogicalDate): Date;
 export declare function dateFromLogicalDate(logicalDate: Maybe<LogicalDate>): Maybe<Date>;
+/**
+ * Determines if the input value is a recognized LogicalDateStringCode.
+ * Currently, only the 'now' value is recognized as a LogicalDateStringCode.
+ *
+ * @param logicalDate - The value to check
+ * @returns True if the value is a recognized LogicalDateStringCode
+ */
 export declare function isLogicalDateStringCode(logicalDate: Maybe<string | LogicalDate>): logicalDate is LogicalDateStringCode;

package/src/lib/date/expires.d.ts

@@ -10,12 +10,12 @@ export interface Expires {
     expiresAt?: Maybe<Date>;
 }
 /**
- * expirationDetails() input.
+ * Input configuration for the expirationDetails() function.
  *
  * The priority that the expiration calculation uses takes the following order:
- * 1. expires
- * 2. expiresAt
- * 3. date + expiresIn
+ * 1. expires - An existing Expires object
+ * 2. expiresAt - A specific date when something expires
+ * 3. expiresFromDate + expiresIn - A base date plus a duration
  */
 export interface ExpirationDetailsInput<T extends Expires = Expires> extends Expires {
     /**
@@ -69,17 +69,20 @@ export interface ExpirationDetails<T extends Expires = Expires> {
     getExpirationDate(nowOverride?: Maybe<Date>): Maybe<Date>;
 }
 /**
- * Returns expiration details for the input.
+ * Returns expiration details for the input configuration.
+ * Creates an object that can determine when something expires based on various inputs.
  *
- * @param input
- * @returns
+ * @template T - The type of Expires object
+ * @param input - Configuration for calculating expiration
+ * @returns An ExpirationDetails object that can determine expiration state
  */
 export declare function expirationDetails<T extends Expires = Expires>(input: ExpirationDetailsInput<T>): ExpirationDetails<T>;
 /**
  * Convenience function for calculating and returning the expiration date given the input.
+ * This is a shorthand for expirationDetails(input).getExpirationDate().
  *
- * @param input Input used to calculate the expiration date.
- * @returns The expiration date, if applicable.
+ * @param input - Input configuration used to calculate the expiration date
+ * @returns The calculated expiration date, or null if no expiration is defined
  */
 export declare function calculateExpirationDate(input: ExpirationDetailsInput<any>): Maybe<Date>;
 /**
@@ -100,29 +103,32 @@ export declare function isUnderThreshold(threshold: Milliseconds, nextRunAt: May
  * Convenience function for quickly calculating throttling given a throttle time and last run time.
  *
  * Returns true if the throttle time has not passed since the last run time, compared to now.
- 
- * @param throttleTime Time after "now" that expiration will occur.
- * @param lastRunAt Time the last run occurred. If the run has never occured then this function will return false.
- * @param now Optional override for the current time. Defaults to the current time.
- * @returns True if the throttle time has not passed since the last run time, compared to now.
+ * This is useful for rate limiting operations (e.g., "only allow this action once every X milliseconds").
+ *
+ * @param throttleTime - Minimum time in milliseconds that must pass between operations
+ * @param lastRunAt - Timestamp when the operation was last performed
+ * @param now - Optional override for the current time (defaults to the current time)
+ * @returns True if the operation should be throttled (not enough time has passed), false otherwise
  */
 export declare function isThrottled(throttleTime: Maybe<Milliseconds>, lastRunAt: Maybe<DateOrUnixDateTimeNumber>, now?: Maybe<Date>): boolean;
 /**
- * Returns true if any of the input ExpirationDetails have not expired.
+ * Returns true if at least one of the input ExpirationDetails has not expired.
+ * Useful for checking if any items in a collection are still valid.
  *
  * If the list is empty, returns false.
  *
- * @param details List of ExpirationDetails to check.
- * @returns True if any of the input ExpirationDetails have not expired.
+ * @param details - Collection of ExpirationDetails to check
+ * @returns True if at least one item has not expired, false otherwise
  */
 export declare function checkAtleastOneNotExpired(details: ExpirationDetails<any>[]): boolean;
 /**
  * Returns true if any of the input ExpirationDetails have expired.
+ * Useful for checking if any items in a collection need to be refreshed or removed.
  *
- * If the list is empty, returns the value of the second argument.
+ * If the list is empty, returns the value specified by defaultIfEmpty.
  *
- * @param details List of ExpirationDetails to check.
- * @param defaultIfEmpty Default value to return if the list is empty. True by default.
- * @returns True if any of the input ExpirationDetails have expired.
+ * @param details - Collection of ExpirationDetails to check
+ * @param defaultIfEmpty - Default value to return if the list is empty (defaults to true)
+ * @returns True if any item has expired, or the defaultIfEmpty value for an empty list
  */
 export declare function checkAnyHaveExpired(details: ExpirationDetails<any>[], defaultIfEmpty?: boolean): boolean;

package/src/lib/date/time.d.ts

@@ -82,33 +82,20 @@ export interface Timer extends Destroyable {
      */
     setDuration(duration: Milliseconds): void;
 }
+/**
+ * Error thrown when the timer is destroyed before it was completed.
+ */
 export declare class TimerCancelledError extends BaseError {
     constructor();
 }
-export declare class TimerInstance implements Timer {
-    private _createdAt;
-    private _startedAt;
-    private _pausedAt?;
-    private _state;
-    private _duration;
-    private _promiseRef;
-    constructor(duration: Milliseconds, startImmediately?: boolean);
-    get state(): TimerState;
-    get createdAt(): Date;
-    get pausedAt(): Maybe<Date>;
-    get startedAt(): Date;
-    get promise(): Promise<void>;
-    get duration(): Milliseconds;
-    get durationRemaining(): Maybe<Milliseconds>;
-    start(): void;
-    stop(): void;
-    reset(): void;
-    setDuration(duration: Milliseconds): void;
-    destroy(): void;
-    private _checkComplete;
-    private _enqueueCheck;
-}
-export declare function timer(duration: Milliseconds, startNow?: boolean): Timer;
+/**
+ * Creates a new Timer from the input duration.
+ *
+ * @param duration - The duration of the timer.
+ * @param startImmediately - Whether the timer should start immediately. Defaults to true.
+ * @returns The new Timer.
+ */
+export declare function makeTimer(duration: Milliseconds, startImmediately?: boolean): Timer;
 /**
  * Toggles the input Timer's running state.
  *
@@ -120,3 +107,7 @@ export declare function toggleTimerRunning(timer: Timer, toggleRun?: boolean): v
  * Returns the approximate end date of the given timer. If a timer is already complete, it returns the time for now.
  */
 export declare function approximateTimerEndDate(timer: Timer): Maybe<Date>;
+/**
+ * @deprecated use makeTimer instead of timer.
+ */
+export declare const timer: typeof makeTimer;

package/src/lib/grouping.d.ts

@@ -121,6 +121,8 @@ export declare function separateValues<T>(values: T[], checkInclusion: DecisionF
  */
 export declare function groupValues<T, R, K extends PrimativeKey & keyof R>(values: T[], groupKeyFn: ReadKeyFunction<T, K>): KeyedGroupingResult<T, R>;
 export declare function groupValues<T, K extends PrimativeKey = PrimativeKey>(values: T[], groupKeyFn: ReadKeyFunction<T, K>): GroupingResult<T>;
+export declare function groupValues<T, R, K extends PrimativeKey & keyof R>(values: Maybe<T[]>, groupKeyFn: ReadKeyFunction<T, K>): KeyedGroupingResult<T, R>;
+export declare function groupValues<T, K extends PrimativeKey = PrimativeKey>(values: Maybe<T[]>, groupKeyFn: ReadKeyFunction<T, K>): GroupingResult<T>;
 /**
  * Reads keys from the values in the arrays, and groups them together into a Map.
  *
@@ -129,3 +131,4 @@ export declare function groupValues<T, K extends PrimativeKey = PrimativeKey>(va
  * @returns
  */
 export declare function makeValuesGroupMap<T, K extends PrimativeKey = PrimativeKey>(values: T[], groupKeyFn: ReadKeyFunction<T, K>): Map<Maybe<K>, T[]>;
+export declare function makeValuesGroupMap<T, K extends PrimativeKey = PrimativeKey>(values: Maybe<T[]>, groupKeyFn: ReadKeyFunction<T, K>): Map<Maybe<K>, T[]>;

package/src/lib/nodejs/stream.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 /**
  * Reads the input stream and encodes the data to a string.
  */

package/src/lib/relation/relation.d.ts

@@ -1,36 +1,40 @@
 import { type Maybe } from '../value/maybe.type';
-export declare enum RelationChange {
+/**
+ * Type of relation change to perform on a collection of models.
+ */
+export declare const RelationChange: {
     /**
      * Adds a model to the relation. If the model already exists in
      * the relation, the new one is used.
      *
      * Use INSERT to merge the two values together.
      */
-    ADD = "add",
+    readonly ADD: "add";
     /**
      * Sets the relation to be equal to the input.
      */
-    SET = "set",
+    readonly SET: "set";
     /**
      * Variation of SET that performs REMOVE on the collection, and then follows it up with INSERT.
      *
      * This can allow the modification function to behave selectively with the items targeted for removal.
      */
-    REMOVE_AND_INSERT = "remove_and_insert",
+    readonly REMOVE_AND_INSERT: "remove_and_insert";
     /**
      * Removes a model from the relation.
      */
-    REMOVE = "remove",
+    readonly REMOVE: "remove";
     /**
      * Updates an existing relation, if it exists.
      * The existing object is merged with the update object.
      */
-    UPDATE = "update",
+    readonly UPDATE: "update";
     /**
      * Updates an existing relation, if it exists, or creates a new one.
      */
-    INSERT = "insert"
-}
+    readonly INSERT: "insert";
+};
+export type RelationChangeType = (typeof RelationChange)[keyof typeof RelationChange];
 export type RelationString = string;
 export type RelationObject = RelationString | object;
 export type RelationModelType = string;
@@ -69,9 +73,9 @@ export interface UpdateMiltiTypeRelationConfig<T> extends UpdateRelationConfig<T
  * For instance, a string collection of keys.
  */
 export declare class ModelRelationUtility {
-    static modifyStringCollection(current: Maybe<RelationString[]>, change: RelationChange, mods: RelationString[]): RelationString[];
-    static modifyCollection<T extends RelationObject>(current: Maybe<T[]>, change: RelationChange, mods: T[], config: UpdateRelationConfig<T>): T[];
-    static modifyCollection<T extends RelationObject>(current: Maybe<T[]>, change: RelationChange, mods: T[], config: UpdateMiltiTypeRelationConfig<T>): T[];
+    static modifyStringCollection(current: Maybe<RelationString[]>, change: RelationChangeType, mods: RelationString[]): RelationString[];
+    static modifyCollection<T extends RelationObject>(current: Maybe<T[]>, change: RelationChangeType, mods: T[], config: UpdateRelationConfig<T>): T[];
+    static modifyCollection<T extends RelationObject>(current: Maybe<T[]>, change: RelationChangeType, mods: T[], config: UpdateMiltiTypeRelationConfig<T>): T[];
     /**
      * The mask results are merged together.
      *

package/src/lib/set/set.delta.d.ts

@@ -4,7 +4,7 @@ import { type PrimativeKey, type ReadKeyFunction } from '../key';
  */
 export declare enum SetDeltaChange {
     REMOVED = -1,
-    NONE = 0,
+    NONE = 0,// No change
     ADDED = 1
 }
 /**

package/src/lib/string/dencoder.d.ts

@@ -59,7 +59,7 @@ export interface PrimativeKeyStringDencoderConfig<D extends PrimativeKey, E exte
  *
  * If a single value is input that produces a nullish value, an error is thrown.
  */
-export type PrimativeKeyStringDencoderFunction<D extends PrimativeKey, E extends PrimativeKey> = ((encodedValues: string) => (E | D)[]) & ((decodedValues: (E | D)[]) => string);
+export type PrimativeKeyStringDencoderFunction<D extends PrimativeKey, E extends PrimativeKey, S extends string = string> = ((encodedValues: S) => (E | D)[]) & ((decodedValues: (E | D)[]) => S);
 /**
  * Creates a new PrimativeKeyStringDencoderFunction.
  *

package/src/lib/string/html.d.ts

@@ -1,13 +1,26 @@
 import { type ArrayOrValue } from './../array/array';
 import { type Maybe } from '../value/maybe.type';
+import { type PrimativeValue } from '../type';
 /**
- * Represents a single CSS class
+ * Represents a single CSS Class
  */
 export type CssClass = string;
+/**
+ * Represents a single CSS Style
+ */
+export type CssStyle = string;
 /**
  * Represents one or more CssClasses that are space separated.
  */
 export type SpaceSeparatedCssClasses = string;
+/**
+ * Key-value object of CSS style values.
+ */
+export type CssStyleObject = Record<string, Maybe<PrimativeValue>>;
+/**
+ * Represents one or more CssStyles that are space separated.
+ */
+export type SpaceSeparatedCssStyles = string;
 /**
  * One or more arrays of one or more CSS classes/arrays of classes.
  */