@timothyw/pat-common 1.0.91 → 1.0.93

package/dist/types/api/account/get-user-types.d.ts

@@ -1,4 +1,5 @@
 import { UserData } from "../../models";
+import { Serialized } from "../../../utils";
 export interface GetUserResponse {
-    user: UserData;
+    user: Serialized<UserData>;
 }

package/dist/types/api/account/update-user-types.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { UserData } from "../../models";
+import { Serialized } from "../../../utils";
 export declare const updateUserRequestSchema: z.ZodObject<{
-    name: z.ZodOptional<z.ZodString>;
     sandbox: z.ZodOptional<z.ZodObject<{
         discordId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
         devices: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -22,6 +22,7 @@ export declare const updateUserRequestSchema: z.ZodObject<{
             pushToken?: string | undefined;
         }[] | undefined;
     }>>;
+    name: z.ZodOptional<z.ZodString>;
     timezone: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     config: z.ZodOptional<z.ZodObject<{
         modules: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -77,13 +78,13 @@ export declare const updateUserRequestSchema: z.ZodObject<{
         }[] | undefined;
     }>>;
 }, "strict", z.ZodTypeAny, {
-    name?: string | undefined;
     sandbox?: {
         discordId?: string | undefined;
         devices?: {
             pushToken?: string | undefined;
         }[] | undefined;
     } | undefined;
+    name?: string | undefined;
     timezone?: string | undefined;
     config?: {
         agenda?: {
@@ -99,13 +100,13 @@ export declare const updateUserRequestSchema: z.ZodObject<{
         }[] | undefined;
     } | undefined;
 }, {
-    name?: string | undefined;
     sandbox?: {
         discordId?: string | undefined;
         devices?: {
             pushToken?: string | undefined;
         }[] | undefined;
     } | undefined;
+    name?: string | undefined;
     timezone?: string | undefined;
     config?: {
         agenda?: {
@@ -123,5 +124,5 @@ export declare const updateUserRequestSchema: z.ZodObject<{
 }>;
 export type UpdateUserRequest = z.infer<typeof updateUserRequestSchema>;
 export interface UpdateUserResponse {
-    user: UserData;
+    user: Serialized<UserData>;
 }

package/dist/types/api/habits/create-habit-entry-types.d.ts

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import { Habit, HabitEntryStatus } from "../../models";
-import { DateOnlyString } from "../../misc-types";
+import { Serialized } from "../../../utils";
 export declare const createHabitEntryRequestSchema: z.ZodObject<{
-    date: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, DateOnlyString, string>;
+    date: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("../../misc-types").DateOnlyString, string>;
     status: z.ZodNativeEnum<typeof HabitEntryStatus>;
 }, "strip", z.ZodTypeAny, {
     status: HabitEntryStatus;
@@ -15,5 +15,5 @@ export declare const createHabitEntryRequestSchema: z.ZodObject<{
 }>;
 export type CreateHabitEntryRequest = z.infer<typeof createHabitEntryRequestSchema>;
 export interface CreateHabitEntryResponse {
-    habit: Habit;
+    habit: Serialized<Habit>;
 }

package/dist/types/api/habits/create-habit-types.d.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { Habit, HabitFrequency } from "../../models/habit-data";
+import { Habit, HabitFrequency } from "../../models";
+import { Serialized } from "../../../utils";
 export declare const createHabitRequestSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
@@ -21,5 +22,5 @@ export declare const createHabitRequestSchema: z.ZodObject<{
 }>;
 export type CreateHabitRequest = z.infer<typeof createHabitRequestSchema>;
 export interface CreateHabitResponse {
-    habit: Habit;
+    habit: Serialized<Habit>;
 }

package/dist/types/api/habits/create-habit-types.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHabitRequestSchema = void 0;
 const zod_1 = require("zod");
-const habit_data_1 = require("../../models/habit-data");
+const models_1 = require("../../models");
 exports.createHabitRequestSchema = zod_1.z.object({
     name: zod_1.z.string().min(1, 'Name is required').trim(),
     description: zod_1.z.string().trim().optional(),
     notes: zod_1.z.string().trim().optional(),
-    frequency: zod_1.z.nativeEnum(habit_data_1.HabitFrequency),
+    frequency: zod_1.z.nativeEnum(models_1.HabitFrequency),
     rolloverTime: zod_1.z.string().regex(/^([01]?[0-9]|2[0-3]):[0-5][0-9]$/, 'rolloverTime must be in HH:MM format')
 });

package/dist/types/api/habits/delete-habit-entry-types.d.ts

@@ -1,4 +1,5 @@
-import { Habit } from "../../models/habit-data";
+import { Habit } from "../../models";
+import { Serialized } from "../../../utils";
 export interface DeleteHabitEntryResponse {
-    habit: Habit;
+    habit: Serialized<Habit>;
 }

package/dist/types/api/habits/get-habits-types.d.ts

@@ -1,4 +1,5 @@
-import { Habit } from "../../models/habit-data";
+import { Habit } from "../../models";
+import { Serialized } from "../../../utils";
 export interface GetHabitsResponse {
-    habits: Habit[];
+    habits: Serialized<Habit>[];
 }

package/dist/types/api/habits/update-habit-types.d.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { Habit, HabitFrequency } from "../../models";
+import { Serialized } from "../../../utils";
 export declare const updateHabitRequestSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -21,5 +22,5 @@ export declare const updateHabitRequestSchema: z.ZodObject<{
 }>;
 export type UpdateHabitRequest = z.infer<typeof updateHabitRequestSchema>;
 export interface UpdateHabitResponse {
-    habit: Habit;
+    habit: Serialized<Habit>;
 }

package/dist/types/api/items/complete-item-types.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
-import { ItemData, Serialized } from "../../models";
+import { ItemData } from "../../models";
+import { Serialized } from "../../../utils";
 export declare const completeItemRequestSchema: z.ZodObject<{
     completed: z.ZodBoolean;
 }, "strip", z.ZodTypeAny, {

package/dist/types/api/items/create-item-types.d.ts

@@ -1,26 +1,27 @@
 import { z } from 'zod';
-import { ItemData, Serialized } from "../../models";
+import { ItemData } from "../../models";
+import { Serialized } from "../../../utils";
 export declare const createItemRequestSchema: z.ZodObject<{
     name: z.ZodString;
-    dueDate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    dueDate: z.ZodOptional<z.ZodString>;
     notes: z.ZodOptional<z.ZodString>;
     urgent: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    category: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    category: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     urgent: boolean;
-    dueDate?: string | null | undefined;
+    type?: string | undefined;
+    dueDate?: string | undefined;
     notes?: string | undefined;
-    category?: string | null | undefined;
-    type?: string | null | undefined;
+    category?: string | undefined;
 }, {
     name: string;
-    dueDate?: string | null | undefined;
+    type?: string | undefined;
+    dueDate?: string | undefined;
     notes?: string | undefined;
     urgent?: boolean | undefined;
-    category?: string | null | undefined;
-    type?: string | null | undefined;
+    category?: string | undefined;
 }>;
 export type CreateItemRequest = z.infer<typeof createItemRequestSchema>;
 export interface CreateItemResponse {

package/dist/types/api/items/create-item-types.js

@@ -4,9 +4,9 @@ exports.createItemRequestSchema = void 0;
 const zod_1 = require("zod");
 exports.createItemRequestSchema = zod_1.z.object({
     name: zod_1.z.string().min(1),
-    dueDate: zod_1.z.string().nullish(),
+    dueDate: zod_1.z.string().optional(),
     notes: zod_1.z.string().optional(),
     urgent: zod_1.z.boolean().optional().default(false),
-    category: zod_1.z.string().nullish(),
-    type: zod_1.z.string().nullish()
+    category: zod_1.z.string().optional(),
+    type: zod_1.z.string().optional()
 });

package/dist/types/api/items/get-items-types.d.ts

@@ -1,4 +1,5 @@
-import { ItemData, Serialized } from "../../models";
+import { ItemData } from "../../models";
+import { Serialized } from "../../../utils";
 export interface GetItemsResponse {
     items: Serialized<ItemData>[];
 }

package/dist/types/api/items/update-item-types.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
-import { ItemData, Serialized } from "../../models";
+import { ItemData } from "../../models";
+import { Serialized } from "../../../utils";
 export declare const updateItemRequestSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     dueDate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -8,19 +9,19 @@ export declare const updateItemRequestSchema: z.ZodObject<{
     category: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, "strip", z.ZodTypeAny, {
+    type?: string | null | undefined;
     name?: string | undefined;
     dueDate?: string | null | undefined;
     notes?: string | null | undefined;
     urgent?: boolean | undefined;
     category?: string | null | undefined;
-    type?: string | null | undefined;
 }, {
+    type?: string | null | undefined;
     name?: string | undefined;
     dueDate?: string | null | undefined;
     notes?: string | null | undefined;
     urgent?: boolean | undefined;
     category?: string | null | undefined;
-    type?: string | null | undefined;
 }>;
 export type UpdateItemRequest = z.infer<typeof updateItemRequestSchema>;
 export interface UpdateItemResponse {

package/dist/types/api/people/create-person-note-types.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { PersonNoteData } from "../../models";
+import { Serialized } from "../../../utils";
 export declare const createPersonNoteRequestSchema: z.ZodObject<{
     personId: z.ZodEffects<z.ZodString, import("../../id-types").PersonId, string>;
     content: z.ZodString;
@@ -14,5 +15,5 @@ export declare const createPersonNoteRequestSchema: z.ZodObject<{
 }>;
 export type CreatePersonNoteRequest = z.infer<typeof createPersonNoteRequestSchema>;
 export interface CreatePersonNoteResponse {
-    personNote: PersonNoteData;
+    personNote: Serialized<PersonNoteData>;
 }

package/dist/types/api/people/create-person-types.d.ts

@@ -1,35 +1,35 @@
 import { z } from 'zod';
-import { PersonNoteId } from "../../id-types";
 import { Person } from "../../models";
+import { Serialized } from "../../../utils";
 export declare const createPersonRequestSchema: z.ZodObject<{
     name: z.ZodString;
     properties: z.ZodOptional<z.ZodArray<z.ZodObject<{
         key: z.ZodString;
         value: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        key: string;
         value: string;
-    }, {
         key: string;
+    }, {
         value: string;
+        key: string;
     }>, "many">>;
-    notes: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, PersonNoteId, string>, "many">>;
+    notes: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, import("../../id-types").PersonNoteId, string>, "many">>;
 }, "strip", z.ZodTypeAny, {
     name: string;
-    notes?: PersonNoteId[] | undefined;
+    notes?: import("../../id-types").PersonNoteId[] | undefined;
     properties?: {
-        key: string;
         value: string;
+        key: string;
     }[] | undefined;
 }, {
     name: string;
     notes?: string[] | undefined;
     properties?: {
-        key: string;
         value: string;
+        key: string;
     }[] | undefined;
 }>;
 export type CreatePersonRequest = z.infer<typeof createPersonRequestSchema>;
 export interface CreatePersonResponse {
-    person: Person;
+    person: Serialized<Person>;
 }

package/dist/types/api/people/get-people-types.d.ts

@@ -1,4 +1,5 @@
 import { Person } from "../../models";
+import { Serialized } from "../../../utils";
 export interface GetPeopleResponse {
-    people: Array<Person>;
+    people: Serialized<Person>[];
 }

package/dist/types/api/people/get-person-notes-types.d.ts

@@ -1,4 +1,5 @@
 import { PersonNoteData } from "../../models";
+import { Serialized } from "../../../utils";
 export interface GetPersonNotesResponse {
-    personNotes: Array<PersonNoteData>;
+    personNotes: Serialized<PersonNoteData>[];
 }

package/dist/types/api/people/update-person-note-types.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { PersonNoteData } from "../../models";
+import { Serialized } from "../../../utils";
 export declare const updatePersonNoteRequestSchema: z.ZodObject<{
     content: z.ZodString;
 }, "strip", z.ZodTypeAny, {
@@ -9,5 +10,5 @@ export declare const updatePersonNoteRequestSchema: z.ZodObject<{
 }>;
 export type UpdatePersonNoteRequest = z.infer<typeof updatePersonNoteRequestSchema>;
 export interface UpdatePersonNoteResponse {
-    personNote: PersonNoteData;
+    personNote: Serialized<PersonNoteData>;
 }

package/dist/types/api/people/update-person-types.d.ts

@@ -1,35 +1,35 @@
 import { z } from 'zod';
-import { PersonNoteId } from "../../id-types";
 import { Person } from "../../models";
+import { Serialized } from "../../../utils";
 export declare const updatePersonRequestSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     properties: z.ZodOptional<z.ZodArray<z.ZodObject<{
         key: z.ZodString;
         value: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        key: string;
         value: string;
-    }, {
         key: string;
+    }, {
         value: string;
+        key: string;
     }>, "many">>;
-    noteIds: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, PersonNoteId, string>, "many">>;
+    noteIds: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, import("../../id-types").PersonNoteId, string>, "many">>;
 }, "strip", z.ZodTypeAny, {
     name?: string | undefined;
     properties?: {
-        key: string;
         value: string;
+        key: string;
     }[] | undefined;
-    noteIds?: PersonNoteId[] | undefined;
+    noteIds?: import("../../id-types").PersonNoteId[] | undefined;
 }, {
     name?: string | undefined;
     properties?: {
-        key: string;
         value: string;
+        key: string;
     }[] | undefined;
     noteIds?: string[] | undefined;
 }>;
 export type UpdatePersonRequest = z.infer<typeof updatePersonRequestSchema>;
 export interface UpdatePersonResponse {
-    person: Person;
+    person: Serialized<Person>;
 }

package/dist/types/api/tasks/complete-task-types.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
-import { TaskId } from "../../id-types";
+import { Serialized } from "../../../utils";
+import { TaskData } from "../../models";
 export declare const completeTaskRequestSchema: z.ZodObject<{
     completed: z.ZodBoolean;
 }, "strip", z.ZodTypeAny, {
@@ -9,13 +10,5 @@ export declare const completeTaskRequestSchema: z.ZodObject<{
 }>;
 export type CompleteTaskRequest = z.infer<typeof completeTaskRequestSchema>;
 export interface CompleteTaskResponse {
-    task: {
-        id: TaskId;
-        name: string;
-        notes?: string;
-        completed: boolean;
-        taskListId: string;
-        createdAt: string;
-        updatedAt: string;
-    };
+    task: Serialized<TaskData>;
 }

package/dist/types/api/tasks/create-task-list-types.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
-import { TaskListId } from "../../id-types";
+import { Serialized } from "../../../utils";
+import { TaskListData } from "../../models";
 export declare const createTaskListRequestSchema: z.ZodObject<{
     name: z.ZodString;
 }, "strip", z.ZodTypeAny, {
@@ -9,10 +10,5 @@ export declare const createTaskListRequestSchema: z.ZodObject<{
 }>;
 export type CreateTaskListRequest = z.infer<typeof createTaskListRequestSchema>;
 export interface CreateTaskListResponse {
-    taskList: {
-        id: TaskListId;
-        name: string;
-        createdAt: string;
-        updatedAt: string;
-    };
+    taskList: Serialized<TaskListData>;
 }

package/dist/types/api/tasks/create-task-types.d.ts

@@ -1,9 +1,10 @@
 import { z } from 'zod';
-import { TaskId, TaskListId } from '../../id-types';
+import { Serialized } from "../../../utils";
+import { TaskData } from "../../models";
 export declare const createTaskRequestSchema: z.ZodObject<{
     name: z.ZodString;
     notes: z.ZodOptional<z.ZodString>;
-    taskListId: z.ZodEffects<z.ZodString, TaskListId, string>;
+    taskListId: z.ZodEffects<z.ZodString, import("../../id-types").TaskListId, string>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     taskListId: string & {
@@ -17,13 +18,5 @@ export declare const createTaskRequestSchema: z.ZodObject<{
 }>;
 export type CreateTaskRequest = z.infer<typeof createTaskRequestSchema>;
 export interface CreateTaskResponse {
-    task: {
-        id: TaskId;
-        name: string;
-        notes?: string;
-        completed: boolean;
-        taskListId: TaskListId;
-        createdAt: string;
-        updatedAt: string;
-    };
+    task: Serialized<TaskData>;
 }

package/dist/types/api/tasks/get-task-lists-types.d.ts

@@ -1,9 +1,5 @@
-import { TaskListId } from "../../id-types";
+import { Serialized } from "../../../utils";
+import { TaskListData } from "../../models";
 export interface GetTaskListsResponse {
-    taskLists: Array<{
-        id: TaskListId;
-        name: string;
-        createdAt: string;
-        updatedAt: string;
-    }>;
+    taskLists: Serialized<TaskListData>[];
 }

package/dist/types/api/tasks/get-tasks-types.d.ts

@@ -1,12 +1,5 @@
-import { TaskId, TaskListId } from "../../id-types";
+import { Serialized } from "../../../utils";
+import { TaskData } from "../../models";
 export interface GetTasksResponse {
-    tasks: Array<{
-        id: TaskId;
-        name: string;
-        notes?: string;
-        completed: boolean;
-        taskListId: TaskListId;
-        createdAt: string;
-        updatedAt: string;
-    }>;
+    tasks: Serialized<TaskData>;
 }

package/dist/types/api/tasks/update-task-list-types.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
-import { TaskListId } from "../../id-types";
+import { Serialized } from "../../../utils";
+import { TaskListData } from "../../models";
 export declare const updateTaskListRequestSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
@@ -9,10 +10,5 @@ export declare const updateTaskListRequestSchema: z.ZodObject<{
 }>;
 export type UpdateTaskListRequest = z.infer<typeof updateTaskListRequestSchema>;
 export interface UpdateTaskListResponse {
-    taskList: {
-        id: TaskListId;
-        name: string;
-        createdAt: string;
-        updatedAt: string;
-    };
+    taskList: Serialized<TaskListData>;
 }

package/dist/types/api/tasks/update-task-types.d.ts

@@ -1,15 +1,16 @@
 import { z } from 'zod';
-import { TaskId, TaskListId } from '../../id-types';
+import { Serialized } from "../../../utils";
+import { TaskData } from "../../models";
 export declare const updateTaskRequestSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     completed: z.ZodOptional<z.ZodBoolean>;
-    taskListId: z.ZodOptional<z.ZodEffects<z.ZodString, TaskListId, string>>;
+    taskListId: z.ZodOptional<z.ZodEffects<z.ZodString, import("../../id-types").TaskListId, string>>;
 }, "strip", z.ZodTypeAny, {
     completed?: boolean | undefined;
     name?: string | undefined;
     notes?: string | null | undefined;
-    taskListId?: TaskListId | undefined;
+    taskListId?: import("../../id-types").TaskListId | undefined;
 }, {
     completed?: boolean | undefined;
     name?: string | undefined;
@@ -18,13 +19,5 @@ export declare const updateTaskRequestSchema: z.ZodObject<{
 }>;
 export type UpdateTaskRequest = z.infer<typeof updateTaskRequestSchema>;
 export interface UpdateTaskResponse {
-    task: {
-        id: TaskId;
-        name: string;
-        notes?: string;
-        completed: boolean;
-        taskListId: TaskListId;
-        createdAt: string;
-        updatedAt: string;
-    };
+    task: Serialized<TaskData>;
 }

package/dist/types/api/thoughts/create-thought-types.d.ts

@@ -1,4 +1,6 @@
 import { z } from 'zod';
+import { Serialized } from "../../../utils";
+import { ThoughtData } from "../../models";
 export declare const createThoughtRequestSchema: z.ZodObject<{
     content: z.ZodString;
 }, "strip", z.ZodTypeAny, {
@@ -8,8 +10,5 @@ export declare const createThoughtRequestSchema: z.ZodObject<{
 }>;
 export type CreateThoughtRequest = z.infer<typeof createThoughtRequestSchema>;
 export interface CreateThoughtResponse {
-    thought: {
-        id: string;
-        content: string;
-    };
+    thought: Serialized<ThoughtData>;
 }

package/dist/types/api/thoughts/get-thoughts-types.d.ts

@@ -1,6 +1,5 @@
+import { Serialized } from "../../../utils";
+import { ThoughtData } from "../../models";
 export interface GetThoughtsResponse {
-    thoughts: Array<{
-        id: string;
-        content: string;
-    }>;
+    thoughts: Serialized<ThoughtData>[];
 }

package/dist/types/api/thoughts/update-thought-types.d.ts

@@ -1,4 +1,6 @@
 import { z } from 'zod';
+import { Serialized } from "../../../utils";
+import { ThoughtData } from "../../models";
 export declare const updateThoughtRequestSchema: z.ZodObject<{
     content: z.ZodString;
 }, "strip", z.ZodTypeAny, {
@@ -8,8 +10,5 @@ export declare const updateThoughtRequestSchema: z.ZodObject<{
 }>;
 export type UpdateThoughtRequest = z.infer<typeof updateThoughtRequestSchema>;
 export interface UpdateThoughtResponse {
-    thought: {
-        id: string;
-        content: string;
-    };
+    thought: Serialized<ThoughtData>;
 }

package/dist/types/models/item-data.d.ts

@@ -12,10 +12,3 @@ export interface ItemData {
     category?: string;
     type?: string;
 }
-export type Serialized<T> = T extends Date ? string : T extends Date | undefined ? string | undefined : T extends Date | null ? string | null : T extends (infer U)[] ? Serialized<U>[] : T extends object ? {
-    [K in keyof T]: Serialized<T[K]>;
-} : T;
-export declare function serialize<T>(obj: T): Serialized<T>;
-export declare function deserialize<T>(obj: Serialized<T>): T;
-export declare function serializeItemData(item: ItemData): Serialized<ItemData>;
-export declare function deserializeItemData(apiData: Serialized<ItemData>): ItemData;

package/dist/types/models/item-data.js

@@ -1,60 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serialize = serialize;
-exports.deserialize = deserialize;
-exports.serializeItemData = serializeItemData;
-exports.deserializeItemData = deserializeItemData;
-function serialize(obj) {
-    return serializeRecursive(obj);
-}
-function deserialize(obj) {
-    return deserializeRecursive(obj);
-}
-function serializeRecursive(obj) {
-    if (obj === null || obj === undefined) {
-        return obj;
-    }
-    if (obj instanceof Date) {
-        return obj.toISOString();
-    }
-    if (Array.isArray(obj)) {
-        return obj.map(item => serializeRecursive(item));
-    }
-    if (typeof obj === 'object') {
-        const result = {};
-        for (const [key, value] of Object.entries(obj)) {
-            result[key] = serializeRecursive(value);
-        }
-        return result;
-    }
-    return obj;
-}
-function deserializeRecursive(obj) {
-    if (obj === null || obj === undefined) {
-        return obj;
-    }
-    if (typeof obj === 'string' && isISODateString(obj)) {
-        return new Date(obj);
-    }
-    if (Array.isArray(obj)) {
-        return obj.map(item => deserializeRecursive(item));
-    }
-    if (typeof obj === 'object') {
-        const result = {};
-        for (const [key, value] of Object.entries(obj)) {
-            result[key] = deserializeRecursive(value);
-        }
-        return result;
-    }
-    return obj;
-}
-function isISODateString(value) {
-    const isoRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/;
-    return isoRegex.test(value) && !isNaN(Date.parse(value));
-}
-function serializeItemData(item) {
-    return serialize(item);
-}
-function deserializeItemData(apiData) {
-    return deserialize(apiData);
-}