@pol-studios/utils 1.0.0

package/dist/format/index.js

@@ -0,0 +1,36 @@
+// src/internal/isUsable.ts
+function isUsable(value) {
+  return value !== void 0 && value !== null && (typeof value !== "number" || isNaN(value) === false);
+}
+
+// src/format/currency.ts
+function formatCurrency(value) {
+  if (isUsable(value) === false) return "";
+  const formatter = new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: "USD"
+  });
+  return formatter.format(value);
+}
+var toUsdString = formatCurrency;
+function toNumberString(value) {
+  const formatter = new Intl.NumberFormat("en-US", {
+    maximumFractionDigits: 2
+  });
+  return formatter.format(value);
+}
+
+// src/format/decimal.ts
+function toDecimalString(num, decimalPlaces) {
+  if (isUsable(num) === false) return "";
+  return num.toLocaleString("en-US", {
+    minimumFractionDigits: decimalPlaces,
+    maximumFractionDigits: decimalPlaces
+  });
+}
+export {
+  formatCurrency,
+  toDecimalString,
+  toNumberString,
+  toUsdString
+};

package/dist/index-B2oAfh_i.d.ts

@@ -0,0 +1,63 @@
+interface ErrorMapping {
+    code?: string;
+    pattern?: RegExp;
+    message: string;
+    action?: string;
+}
+interface UserFriendlyError {
+    message: string;
+    action?: string;
+}
+interface PostgrestError {
+    code: string;
+    message: string;
+    details?: string;
+    hint?: string;
+}
+/**
+ * Maps a technical error to a user-friendly error message
+ */
+declare function getUserFriendlyError(error: Error | PostgrestError | any): UserFriendlyError;
+/**
+ * Checks if an error is a Supabase PostgREST error
+ */
+declare function isPostgrestError(error: any): error is PostgrestError;
+/**
+ * Checks if an error is a network error
+ */
+declare function isNetworkError(error: any): boolean;
+
+/**
+ * Maps form validation errors to user-friendly field-specific messages
+ */
+interface ValidationErrorMapping {
+    pattern?: RegExp;
+    message: string;
+    action?: string;
+}
+/**
+ * Maps a validation error message to a user-friendly field-specific message
+ */
+declare function getFormFieldError(error: string | Error | null | undefined): {
+    message: string;
+    action?: string;
+} | null;
+/**
+ * Extracts field name from error message for better context
+ */
+declare function extractFieldName(errorMessage: string): string | null;
+
+type index_ErrorMapping = ErrorMapping;
+type index_PostgrestError = PostgrestError;
+type index_UserFriendlyError = UserFriendlyError;
+type index_ValidationErrorMapping = ValidationErrorMapping;
+declare const index_extractFieldName: typeof extractFieldName;
+declare const index_getFormFieldError: typeof getFormFieldError;
+declare const index_getUserFriendlyError: typeof getUserFriendlyError;
+declare const index_isNetworkError: typeof isNetworkError;
+declare const index_isPostgrestError: typeof isPostgrestError;
+declare namespace index {
+  export { type index_ErrorMapping as ErrorMapping, type index_PostgrestError as PostgrestError, type index_UserFriendlyError as UserFriendlyError, type index_ValidationErrorMapping as ValidationErrorMapping, index_extractFieldName as extractFieldName, index_getFormFieldError as getFormFieldError, index_getUserFriendlyError as getUserFriendlyError, index_isNetworkError as isNetworkError, index_isPostgrestError as isPostgrestError };
+}
+
+export { type ErrorMapping as E, type PostgrestError as P, type UserFriendlyError as U, type ValidationErrorMapping as V, isPostgrestError as a, isNetworkError as b, getFormFieldError as c, extractFieldName as e, getUserFriendlyError as g, index as i };

package/dist/index-BDWEMkWa.d.ts

@@ -0,0 +1,56 @@
+import { Moment } from 'moment';
+
+/**
+ * Returns the current date/time in UTC
+ */
+declare function getUtcDate(): Date;
+/**
+ * Converts a Date to UTC
+ */
+declare function toUtcDate(date: Date | undefined | null): Date | null;
+/**
+ * Returns the current moment in UTC
+ */
+declare function getUtcMoment(): Moment;
+
+/**
+ * Compares two Moment dates for equality
+ */
+declare function areDatesEqual(date1: Moment, date2: Moment): boolean;
+
+/**
+ * JSON reviver function that converts date strings to Moment objects
+ */
+declare function dateReviver(key: any, value: any): any;
+/**
+ * JSON reviver function that converts date strings to Date objects
+ */
+declare function parseWithDate(key: any, value: any): any;
+/**
+ * Checks if a Date object is valid
+ */
+declare function isValidDate(date: Date): boolean;
+
+/**
+ * Adds the duration between two dates to the first date
+ */
+declare function addDates(date1: Moment, date2: Moment): Moment;
+/**
+ * Adds a number of days to a Moment date
+ */
+declare function addDays(date1: Moment, days: number): Moment;
+
+declare const index_addDates: typeof addDates;
+declare const index_addDays: typeof addDays;
+declare const index_areDatesEqual: typeof areDatesEqual;
+declare const index_dateReviver: typeof dateReviver;
+declare const index_getUtcDate: typeof getUtcDate;
+declare const index_getUtcMoment: typeof getUtcMoment;
+declare const index_isValidDate: typeof isValidDate;
+declare const index_parseWithDate: typeof parseWithDate;
+declare const index_toUtcDate: typeof toUtcDate;
+declare namespace index {
+  export { index_addDates as addDates, index_addDays as addDays, index_areDatesEqual as areDatesEqual, index_dateReviver as dateReviver, index_getUtcDate as getUtcDate, index_getUtcMoment as getUtcMoment, index_isValidDate as isValidDate, index_parseWithDate as parseWithDate, index_toUtcDate as toUtcDate };
+}
+
+export { getUtcMoment as a, areDatesEqual as b, isValidDate as c, dateReviver as d, addDates as e, addDays as f, getUtcDate as g, index as i, parseWithDate as p, toUtcDate as t };

package/dist/index-BSNY-QEc.d.ts

@@ -0,0 +1,15 @@
+import { ClassValue } from 'clsx';
+
+/**
+ * Merges Tailwind CSS classes with conflict resolution
+ * Combines clsx for conditional classes with tailwind-merge for deduplication
+ */
+declare function cn(...inputs: ClassValue[]): string;
+
+declare const index_ClassValue: typeof ClassValue;
+declare const index_cn: typeof cn;
+declare namespace index {
+  export { index_ClassValue as ClassValue, index_cn as cn };
+}
+
+export { cn as c, index as i };

package/dist/index-BaA8cg0E.d.ts

@@ -0,0 +1,100 @@
+declare function isUsable(value: any): value is {};
+
+type ItemType<T> = T extends Array<infer U> ? U : T;
+type KeyOfStringOrNumber<T> = {
+    [K in keyof T]: K extends symbol ? never : K;
+}[keyof T];
+
+type EntityType = 'Project' | 'Client' | 'ProjectDatabase';
+type EntityPermissionLevel = 'ReadOnly' | 'AdminReadOnly' | 'ReadWrite' | 'Admin';
+type PermissionEffect = 'allow' | 'deny';
+type EntityAction = 'view' | 'adminView' | 'edit' | 'create' | 'delete' | 'share';
+interface EntityPermissionCheck {
+    canView: boolean;
+    canAdminView: boolean;
+    canEdit: boolean;
+    canCreate: boolean;
+    canDelete: boolean;
+    canShare: boolean;
+    permissionLevel: EntityPermissionLevel | null;
+    isLoading: boolean;
+    /** Whether access was explicitly denied */
+    isDenied?: boolean;
+}
+interface EntityAccessRecord {
+    id: number;
+    userId: string;
+    entityType: EntityType;
+    entityId: number;
+    permission: EntityPermissionLevel;
+    /** Permission effect - 'allow' grants access, 'deny' explicitly blocks */
+    effect: PermissionEffect;
+    inheritedFromClientId?: number | null;
+    inheritFromProject?: boolean;
+    /** User ID who granted this permission */
+    grantedBy?: string | null;
+    /** ISO timestamp when permission was granted */
+    grantedAt?: string;
+    /** ISO timestamp when permission expires, null for never */
+    expiresAt?: string | null;
+}
+
+/**
+ * Metadata stored in storage.objects.metadata JSONB column
+ * Used to track custom attachment properties after consolidation
+ */
+interface StorageObjectMetadata {
+    /** Processing status for async operations (e.g., embedding generation) */
+    processingStatus: "None" | "Processing" | "Error";
+    /** Uppercase content type derived from MIME (e.g., "JPEG", "PDF", "MP4") */
+    contentType: string;
+    /** Image/video height in pixels */
+    contentHeight?: number;
+    /** Image/video width in pixels */
+    contentWidth?: number;
+    /** Original filename before UUID renaming */
+    originalFileName?: string;
+    /** Legacy attachment ID for rollback/migration tracking */
+    legacyAttachmentId?: number;
+}
+/**
+ * Get content type from metadata or infer from file path extension
+ */
+declare function getContentType(metadata: StorageObjectMetadata | null | undefined, path: string): string;
+/**
+ * Check if content type represents an image
+ */
+declare function isImageType(contentType: string): boolean;
+/**
+ * Check if content type represents a video
+ */
+declare function isVideoType(contentType: string): boolean;
+/**
+ * Check if content type represents a PDF document
+ */
+declare function isPdfType(contentType: string): boolean;
+/**
+ * Check if content type represents a renderable file (image, video, or PDF)
+ */
+declare function isRenderableType(contentType: string): boolean;
+
+type index_EntityAccessRecord = EntityAccessRecord;
+type index_EntityAction = EntityAction;
+type index_EntityPermissionCheck = EntityPermissionCheck;
+type index_EntityPermissionLevel = EntityPermissionLevel;
+type index_EntityType = EntityType;
+type index_ItemType<T> = ItemType<T>;
+type index_KeyOfStringOrNumber<T> = KeyOfStringOrNumber<T>;
+type index_PermissionEffect = PermissionEffect;
+type index_StorageObjectMetadata = StorageObjectMetadata;
+declare const index_getContentType: typeof getContentType;
+declare const index_isImageType: typeof isImageType;
+declare const index_isPdfType: typeof isPdfType;
+declare const index_isRenderableType: typeof isRenderableType;
+declare const index_isUsable: typeof isUsable;
+declare const index_isVideoType: typeof isVideoType;
+declare namespace index {
+  export { type index_EntityAccessRecord as EntityAccessRecord, type index_EntityAction as EntityAction, type index_EntityPermissionCheck as EntityPermissionCheck, type index_EntityPermissionLevel as EntityPermissionLevel, type index_EntityType as EntityType, type index_ItemType as ItemType, type index_KeyOfStringOrNumber as KeyOfStringOrNumber, type index_PermissionEffect as PermissionEffect, type index_StorageObjectMetadata as StorageObjectMetadata, index_getContentType as getContentType, index_isImageType as isImageType, index_isPdfType as isPdfType, index_isRenderableType as isRenderableType, index_isUsable as isUsable, index_isVideoType as isVideoType };
+}
+
+export { type EntityType as E, type ItemType as I, type KeyOfStringOrNumber as K, type PermissionEffect as P, type StorageObjectMetadata as S, type EntityPermissionLevel as a, type EntityAction as b, type EntityPermissionCheck as c, type EntityAccessRecord as d, isImageType as e, isVideoType as f, getContentType as g, isPdfType as h, index as i, isRenderableType as j, isUsable as k };

package/dist/index-Btn_GVfm.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Generates a new UUID v4-like string.
+ * Note: This is not cryptographically secure and uses Math.random().
+ * @returns A UUID string in the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+ */
+declare function newUuid(): string;
+
+declare const index_newUuid: typeof newUuid;
+declare namespace index {
+  export { index_newUuid as newUuid };
+}
+
+export { index as i, newUuid as n };

package/dist/index-BxUoIlv_.d.ts

@@ -0,0 +1,39 @@
+type ValidationRule<T = string> = {
+    validate: (value: T) => boolean;
+    message: string;
+};
+type ValidationResult = {
+    isValid: boolean;
+    error?: string;
+};
+declare function validateValue<T>(value: T, rules: ValidationRule<T>[]): ValidationResult;
+declare function validateEmail(email: string): ValidationResult;
+declare function validateRequired(value: string | number | null | undefined): ValidationResult;
+declare function validateMinLength(min: number): (value: string) => ValidationResult;
+declare function validateMaxLength(max: number): (value: string) => ValidationResult;
+declare function validatePattern(pattern: RegExp, message: string): (value: string) => ValidationResult;
+
+type PasswordStrength = "weak" | "fair" | "good" | "strong";
+interface PasswordStrengthResult {
+    strength: PasswordStrength;
+    score: number;
+    feedback: string[];
+}
+declare function calculatePasswordStrength(password: string): PasswordStrengthResult;
+
+type index_PasswordStrength = PasswordStrength;
+type index_PasswordStrengthResult = PasswordStrengthResult;
+type index_ValidationResult = ValidationResult;
+type index_ValidationRule<T = string> = ValidationRule<T>;
+declare const index_calculatePasswordStrength: typeof calculatePasswordStrength;
+declare const index_validateEmail: typeof validateEmail;
+declare const index_validateMaxLength: typeof validateMaxLength;
+declare const index_validateMinLength: typeof validateMinLength;
+declare const index_validatePattern: typeof validatePattern;
+declare const index_validateRequired: typeof validateRequired;
+declare const index_validateValue: typeof validateValue;
+declare namespace index {
+  export { type index_PasswordStrength as PasswordStrength, type index_PasswordStrengthResult as PasswordStrengthResult, type index_ValidationResult as ValidationResult, type index_ValidationRule as ValidationRule, index_calculatePasswordStrength as calculatePasswordStrength, index_validateEmail as validateEmail, index_validateMaxLength as validateMaxLength, index_validateMinLength as validateMinLength, index_validatePattern as validatePattern, index_validateRequired as validateRequired, index_validateValue as validateValue };
+}
+
+export { type PasswordStrength as P, type ValidationRule as V, type ValidationResult as a, validateEmail as b, validateRequired as c, validateMinLength as d, validateMaxLength as e, validatePattern as f, type PasswordStrengthResult as g, calculatePasswordStrength as h, index as i, validateValue as v };

package/dist/index-ByjfWGR4.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Sort an array of objects by a property
+ * @param items - The array to sort
+ * @param property - The property to sort by
+ * @param isAscending - Whether to sort ascending (default: false for descending)
+ * @returns A new sorted array
+ */
+declare function sortBy<T>(items: T[], property: keyof T, isAscending?: boolean): T[];
+/**
+ * Sort an array using a custom accessor function
+ * @param items - The array to sort
+ * @param func - Function that extracts the value to sort by
+ * @param isAscending - Whether to sort ascending (default: false for descending)
+ * @returns A new sorted array
+ */
+declare function sort<T>(items: T[], func: (item: T) => any, isAscending?: boolean): T[];
+/**
+ * Select the item with the minimum value based on a selector function
+ * @param items - The array to search
+ * @param action - Function that extracts the value to compare
+ * @returns The item with the minimum value
+ */
+declare function selectByMin<T>(items: T[], action: (item: T) => any): T;
+
+interface GroupedItems<T> {
+    items: T[];
+}
+/**
+ * Group an array by a key or function
+ * @param list - The array to group
+ * @param key - The property name or function to extract the grouping key
+ * @returns A Map of grouped items
+ */
+declare function groupBy<T>(list: T[], key: (keyof T & string) | ((item: T) => any)): Map<any, T[]>;
+/**
+ * Group an array by multiple criteria
+ * @param items - The array to group
+ * @param criteria - Array of property names to group by
+ * @returns Array of grouped items
+ */
+declare function groupByMultipleCriteria<T>(items: Array<T>, criteria: Array<keyof T>): Array<GroupedItems<T>>;
+
+/**
+ * Split an array into chunks of a specified size
+ * @param array - The array to chunk
+ * @param chunkSize - The size of each chunk
+ * @returns An array of chunks
+ * @throws Error if chunkSize is less than or equal to 0
+ * @example chunk([1, 2, 3, 4, 5], 2) // [[1, 2], [3, 4], [5]]
+ */
+declare function chunk<T>(array: T[], chunkSize: number): T[][];
+/**
+ * @deprecated Use `chunk` instead
+ * Split an array into chunks of a specified size
+ * @param array - The array to chunk
+ * @param chunkSize - The size of each chunk
+ * @returns An array of chunks
+ */
+declare const chunkArray: typeof chunk;
+
+/**
+ * Extract unique values from an array of objects by a specified key
+ * @param array - The array to process
+ * @param key - The key to extract unique values from
+ * @returns An array of unique values
+ * @example unique([{id: 1}, {id: 2}, {id: 1}], 'id') // [1, 2]
+ */
+declare function unique<T>(array: T[], key: keyof T): any[];
+/**
+ * @deprecated Use `unique` instead
+ * Extract unique values from an array of objects by a specified key
+ * @param array - The array to process
+ * @param key - The key to extract unique values from
+ * @returns An array of unique values
+ */
+declare const mapUnique: typeof unique;
+/**
+ * @deprecated Use `unique` instead - note: original had typo in name
+ * Extract unique values from an array of objects by a specified key
+ * @param array - The array to process
+ * @param key - The key to extract unique values from
+ * @returns An array of unique values
+ */
+declare const mapUnqiue: typeof unique;
+
+/**
+ * Create an array of numbers in a range
+ * @param size - The number of elements
+ * @param startAt - The starting value (default: 0)
+ * @returns A readonly array of numbers
+ * @example range(5) // [0, 1, 2, 3, 4]
+ * @example range(5, 1) // [1, 2, 3, 4, 5]
+ */
+declare function range(size: number, startAt?: number): ReadonlyArray<number>;
+
+/**
+ * Calculate the sum of an array of numbers with fallback
+ * @param itemsArray - The array of numbers to sum
+ * @param defaultValue - The default value if array is empty or invalid (default: 0)
+ * @returns The sum of the array or the default value
+ */
+declare function tryGetSum(itemsArray: number[], defaultValue?: number): number;
+
+/**
+ * Calculate the average of an array of numbers with fallback
+ * @param items - The array of numbers
+ * @param defaultValue - The default value if array is empty or invalid (default: 0)
+ * @returns The average of the array or the default value
+ */
+declare function tryGetAverage(items: number[], defaultValue?: number): number;
+/**
+ * Calculate the average of an array of numbers
+ * @param arr - The array of numbers
+ * @returns The average of the array
+ * @note This function does not handle empty arrays - use tryGetAverage for that
+ */
+declare function getAverage(arr: number[]): number;
+
+/**
+ * Convert an array of objects to a keyed object
+ * @param array - The array to convert
+ * @param key - The key to use as the object key
+ * @returns A record keyed by the specified property
+ * @example convertArrayToObject([{id: 1, name: 'a'}, {id: 2, name: 'b'}], 'id')
+ * // { 1: {id: 1, name: 'a'}, 2: {id: 2, name: 'b'} }
+ */
+declare function convertArrayToObject<T extends {
+    [key in K]: number;
+}, K extends keyof T>(array: T[], key: K): Record<string, T>;
+
+type index_GroupedItems<T> = GroupedItems<T>;
+declare const index_chunk: typeof chunk;
+declare const index_chunkArray: typeof chunkArray;
+declare const index_convertArrayToObject: typeof convertArrayToObject;
+declare const index_getAverage: typeof getAverage;
+declare const index_groupBy: typeof groupBy;
+declare const index_groupByMultipleCriteria: typeof groupByMultipleCriteria;
+declare const index_mapUnique: typeof mapUnique;
+declare const index_mapUnqiue: typeof mapUnqiue;
+declare const index_range: typeof range;
+declare const index_selectByMin: typeof selectByMin;
+declare const index_sort: typeof sort;
+declare const index_sortBy: typeof sortBy;
+declare const index_tryGetAverage: typeof tryGetAverage;
+declare const index_tryGetSum: typeof tryGetSum;
+declare const index_unique: typeof unique;
+declare namespace index {
+  export { type index_GroupedItems as GroupedItems, index_chunk as chunk, index_chunkArray as chunkArray, index_convertArrayToObject as convertArrayToObject, index_getAverage as getAverage, index_groupBy as groupBy, index_groupByMultipleCriteria as groupByMultipleCriteria, index_mapUnique as mapUnique, index_mapUnqiue as mapUnqiue, index_range as range, index_selectByMin as selectByMin, index_sort as sort, index_sortBy as sortBy, index_tryGetAverage as tryGetAverage, index_tryGetSum as tryGetSum, index_unique as unique };
+}
+
+export { type GroupedItems as G, sort as a, selectByMin as b, groupByMultipleCriteria as c, chunk as d, chunkArray as e, mapUnqiue as f, groupBy as g, tryGetAverage as h, index as i, getAverage as j, convertArrayToObject as k, mapUnique as m, range as r, sortBy as s, tryGetSum as t, unique as u };

package/dist/index-C-YwC08Y.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Returns a promise that resolves after the specified number of milliseconds
+ */
+declare function delay(ms: number): Promise<void>;
+
+/**
+ * Debounces a function call by the specified wait time
+ */
+declare function debounce<T extends (...args: any[]) => void>(func: T, wait: number): void;
+
+/**
+ * Executes an array of async tasks with a concurrency limit
+ * @param tasks - Array of functions that return promises
+ * @param concurrency - Maximum number of concurrent tasks
+ * @returns Promise resolving to an array of results in the same order as input tasks
+ */
+declare function concurrent<T>(tasks: Array<() => Promise<T>>, concurrency: number): Promise<T[]>;
+/**
+ * @deprecated Use `concurrent` instead
+ * Executes an array of async tasks with a concurrency limit
+ */
+declare const promiseAllWithConcurrencyLimit: typeof concurrent;
+
+/**
+ * A semaphore implementation for controlling concurrent access
+ */
+declare class Semaphore {
+    private tasks;
+    private count;
+    constructor(count: number);
+    acquire(): Promise<void>;
+    release(): void;
+}
+
+type index_Semaphore = Semaphore;
+declare const index_Semaphore: typeof Semaphore;
+declare const index_concurrent: typeof concurrent;
+declare const index_debounce: typeof debounce;
+declare const index_delay: typeof delay;
+declare const index_promiseAllWithConcurrencyLimit: typeof promiseAllWithConcurrencyLimit;
+declare namespace index {
+  export { index_Semaphore as Semaphore, index_concurrent as concurrent, index_debounce as debounce, index_delay as delay, index_promiseAllWithConcurrencyLimit as promiseAllWithConcurrencyLimit };
+}
+
+export { Semaphore as S, debounce as a, concurrent as c, delay as d, index as i, promiseAllWithConcurrencyLimit as p };

package/dist/index-C062CkPL.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Checks if the current viewport width indicates a small device (mobile).
+ * @returns true if window width is 640px or less
+ */
+declare function isSmallDevice(): boolean;
+/**
+ * Checks if the current device is an iPhone based on user agent.
+ * @returns true if running on an iPhone
+ */
+declare function isIphone(): boolean;
+/**
+ * Checks if the app was launched as a Progressive Web App (PWA).
+ * Supports both iOS (navigator.standalone) and Android/other devices (display-mode: standalone).
+ * @returns true if running as a PWA, false if running in browser
+ */
+declare function isPwaLaunched(): boolean;
+/**
+ * Asynchronously checks if the device has a camera available.
+ * @returns Promise resolving to true if a video input device exists
+ */
+declare function hasCameraAsync(): Promise<boolean>;
+
+declare const index_hasCameraAsync: typeof hasCameraAsync;
+declare const index_isIphone: typeof isIphone;
+declare const index_isPwaLaunched: typeof isPwaLaunched;
+declare const index_isSmallDevice: typeof isSmallDevice;
+declare namespace index {
+  export { index_hasCameraAsync as hasCameraAsync, index_isIphone as isIphone, index_isPwaLaunched as isPwaLaunched, index_isSmallDevice as isSmallDevice };
+}
+
+export { isSmallDevice as a, isIphone as b, isPwaLaunched as c, hasCameraAsync as h, index as i };

package/dist/index-C8CxeaqZ.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Creates a new object with the original item's properties merged with updates.
+ * Immutable update pattern - returns a new object without modifying the original.
+ * @param item - The original object
+ * @param updates - Partial object with properties to update
+ * @returns A new object with merged properties
+ */
+declare function withUpdate<T>(item: T, updates: Partial<T>): T;
+/**
+ * Compares two objects and returns only the properties that have changed.
+ * Performs shallow comparison of property values.
+ * @param oldObj - The original object
+ * @param newObj - The new object to compare against
+ * @returns A partial object containing only the changed properties with their new values
+ */
+declare function getObjectChanges<T extends Record<string, any>>(oldObj: T, newObj: T): Partial<T>;
+
+declare const index_getObjectChanges: typeof getObjectChanges;
+declare const index_withUpdate: typeof withUpdate;
+declare namespace index {
+  export { index_getObjectChanges as getObjectChanges, index_withUpdate as withUpdate };
+}
+
+export { getObjectChanges as g, index as i, withUpdate as w };