@timothyw/pat-common 1.0.113 → 1.0.116

package/dist/types/new/habits-types.d.ts

@@ -0,0 +1,317 @@
+import { z } from 'zod';
+import { Serialized } from '../../utils';
+export declare enum HabitFrequency {
+    DAILY = "daily",
+    WEEKLY = "weekly",
+    EVERY_N_DAYS = "every_n_days",
+    WEEKDAYS_ONLY = "weekdays_only",
+    CUSTOM = "custom"
+}
+export declare enum HabitEntryStatus {
+    COMPLETED = "completed",
+    EXCUSED = "excused",
+    MISSED = "missed"
+}
+export declare const habitEntrySchema: z.ZodObject<{
+    _id: z.ZodEffects<z.ZodString, import("../id-types").HabitEntryId, string>;
+    habitId: z.ZodEffects<z.ZodString, import("../id-types").HabitId, string>;
+    userId: z.ZodEffects<z.ZodString, import("../id-types").UserId, string>;
+    date: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("../misc-types").DateOnlyString, string>;
+    status: z.ZodNativeEnum<typeof HabitEntryStatus>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    _id: string & {
+        readonly __brand: "HabitEntryId";
+    };
+    createdAt: Date;
+    updatedAt: Date;
+    userId: string & {
+        readonly __brand: "UserId";
+    };
+    status: HabitEntryStatus;
+    date: string & {
+        readonly __brand: "DateOnlyString";
+    };
+    habitId: string & {
+        readonly __brand: "HabitId";
+    };
+}, {
+    _id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    userId: string;
+    status: HabitEntryStatus;
+    date: string;
+    habitId: string;
+}>;
+export declare const habitDataSchema: z.ZodObject<{
+    _id: z.ZodEffects<z.ZodString, import("../id-types").HabitId, string>;
+    userId: z.ZodEffects<z.ZodString, import("../id-types").UserId, string>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    frequency: z.ZodNativeEnum<typeof HabitFrequency>;
+    rolloverTime: z.ZodString;
+    firstDay: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("../misc-types").DateOnlyString, string>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    _id: string & {
+        readonly __brand: "HabitId";
+    };
+    createdAt: Date;
+    updatedAt: Date;
+    userId: string & {
+        readonly __brand: "UserId";
+    };
+    name: string;
+    frequency: HabitFrequency;
+    rolloverTime: string;
+    firstDay: string & {
+        readonly __brand: "DateOnlyString";
+    };
+    description?: string | null | undefined;
+    notes?: string | null | undefined;
+}, {
+    _id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    userId: string;
+    name: string;
+    frequency: HabitFrequency;
+    rolloverTime: string;
+    firstDay: string;
+    description?: string | null | undefined;
+    notes?: string | null | undefined;
+}>;
+export declare const habitStatsSchema: z.ZodObject<{
+    totalDays: z.ZodNumber;
+    completedDays: z.ZodNumber;
+    excusedDays: z.ZodNumber;
+    missedDays: z.ZodNumber;
+    completionRate: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    totalDays: number;
+    completedDays: number;
+    excusedDays: number;
+    missedDays: number;
+    completionRate: number;
+}, {
+    totalDays: number;
+    completedDays: number;
+    excusedDays: number;
+    missedDays: number;
+    completionRate: number;
+}>;
+export declare const habitSchema: z.ZodObject<{
+    _id: z.ZodEffects<z.ZodString, import("../id-types").HabitId, string>;
+    userId: z.ZodEffects<z.ZodString, import("../id-types").UserId, string>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    frequency: z.ZodNativeEnum<typeof HabitFrequency>;
+    rolloverTime: z.ZodString;
+    firstDay: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("../misc-types").DateOnlyString, string>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+} & {
+    entries: z.ZodArray<z.ZodObject<{
+        _id: z.ZodEffects<z.ZodString, import("../id-types").HabitEntryId, string>;
+        habitId: z.ZodEffects<z.ZodString, import("../id-types").HabitId, string>;
+        userId: z.ZodEffects<z.ZodString, import("../id-types").UserId, string>;
+        date: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("../misc-types").DateOnlyString, string>;
+        status: z.ZodNativeEnum<typeof HabitEntryStatus>;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+    }, "strip", z.ZodTypeAny, {
+        _id: string & {
+            readonly __brand: "HabitEntryId";
+        };
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string & {
+            readonly __brand: "UserId";
+        };
+        status: HabitEntryStatus;
+        date: string & {
+            readonly __brand: "DateOnlyString";
+        };
+        habitId: string & {
+            readonly __brand: "HabitId";
+        };
+    }, {
+        _id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string;
+        status: HabitEntryStatus;
+        date: string;
+        habitId: string;
+    }>, "many">;
+    stats: z.ZodObject<{
+        totalDays: z.ZodNumber;
+        completedDays: z.ZodNumber;
+        excusedDays: z.ZodNumber;
+        missedDays: z.ZodNumber;
+        completionRate: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        totalDays: number;
+        completedDays: number;
+        excusedDays: number;
+        missedDays: number;
+        completionRate: number;
+    }, {
+        totalDays: number;
+        completedDays: number;
+        excusedDays: number;
+        missedDays: number;
+        completionRate: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    _id: string & {
+        readonly __brand: "HabitId";
+    };
+    createdAt: Date;
+    updatedAt: Date;
+    userId: string & {
+        readonly __brand: "UserId";
+    };
+    entries: {
+        _id: string & {
+            readonly __brand: "HabitEntryId";
+        };
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string & {
+            readonly __brand: "UserId";
+        };
+        status: HabitEntryStatus;
+        date: string & {
+            readonly __brand: "DateOnlyString";
+        };
+        habitId: string & {
+            readonly __brand: "HabitId";
+        };
+    }[];
+    name: string;
+    frequency: HabitFrequency;
+    rolloverTime: string;
+    firstDay: string & {
+        readonly __brand: "DateOnlyString";
+    };
+    stats: {
+        totalDays: number;
+        completedDays: number;
+        excusedDays: number;
+        missedDays: number;
+        completionRate: number;
+    };
+    description?: string | null | undefined;
+    notes?: string | null | undefined;
+}, {
+    _id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    userId: string;
+    entries: {
+        _id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string;
+        status: HabitEntryStatus;
+        date: string;
+        habitId: string;
+    }[];
+    name: string;
+    frequency: HabitFrequency;
+    rolloverTime: string;
+    firstDay: string;
+    stats: {
+        totalDays: number;
+        completedDays: number;
+        excusedDays: number;
+        missedDays: number;
+        completionRate: number;
+    };
+    description?: string | null | undefined;
+    notes?: string | null | undefined;
+}>;
+export declare const createHabitRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+    frequency: z.ZodNativeEnum<typeof HabitFrequency>;
+    rolloverTime: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    frequency: HabitFrequency;
+    rolloverTime: string;
+    description?: string | undefined;
+    notes?: string | undefined;
+}, {
+    name: string;
+    frequency: HabitFrequency;
+    rolloverTime: string;
+    description?: string | undefined;
+    notes?: string | undefined;
+}>;
+export declare const updateHabitRequestSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    frequency: z.ZodOptional<z.ZodNativeEnum<typeof HabitFrequency>>;
+    rolloverTime: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    description?: string | null | undefined;
+    notes?: string | null | undefined;
+    frequency?: HabitFrequency | undefined;
+    rolloverTime?: string | undefined;
+}, {
+    name?: string | undefined;
+    description?: string | null | undefined;
+    notes?: string | null | undefined;
+    frequency?: HabitFrequency | undefined;
+    rolloverTime?: string | undefined;
+}>;
+export declare const createHabitEntryRequestSchema: z.ZodObject<{
+    date: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("../misc-types").DateOnlyString, string>;
+    status: z.ZodNativeEnum<typeof HabitEntryStatus>;
+}, "strip", z.ZodTypeAny, {
+    status: HabitEntryStatus;
+    date: string & {
+        readonly __brand: "DateOnlyString";
+    };
+}, {
+    status: HabitEntryStatus;
+    date: string;
+}>;
+export type HabitEntryData = z.infer<typeof habitEntrySchema>;
+export type HabitData = z.infer<typeof habitDataSchema>;
+export type HabitStats = z.infer<typeof habitStatsSchema>;
+export type Habit = z.infer<typeof habitSchema>;
+export type CreateHabitRequest = z.infer<typeof createHabitRequestSchema>;
+export type UpdateHabitRequest = z.infer<typeof updateHabitRequestSchema>;
+export type CreateHabitEntryRequest = z.infer<typeof createHabitEntryRequestSchema>;
+export interface CreateHabitResponse {
+    habit: Serialized<Habit>;
+}
+export interface GetHabitsResponse {
+    habits: Serialized<Habit>[];
+}
+export interface GetHabitResponse {
+    habit: Serialized<Habit>;
+}
+export interface UpdateHabitResponse {
+    habit: Serialized<Habit>;
+}
+export interface DeleteHabitResponse {
+    deleted: boolean;
+}
+export interface CreateHabitEntryResponse {
+    habit: Serialized<Habit>;
+}
+export interface DeleteHabitEntryResponse {
+    habit: Serialized<Habit>;
+}

package/dist/types/new/habits-types.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHabitEntryRequestSchema = exports.updateHabitRequestSchema = exports.createHabitRequestSchema = exports.habitSchema = exports.habitStatsSchema = exports.habitDataSchema = exports.habitEntrySchema = exports.HabitEntryStatus = exports.HabitFrequency = void 0;
+const zod_1 = require("zod");
+const id_types_1 = require("../id-types");
+const misc_types_1 = require("../misc-types");
+var HabitFrequency;
+(function (HabitFrequency) {
+    HabitFrequency["DAILY"] = "daily";
+    HabitFrequency["WEEKLY"] = "weekly";
+    HabitFrequency["EVERY_N_DAYS"] = "every_n_days";
+    HabitFrequency["WEEKDAYS_ONLY"] = "weekdays_only";
+    HabitFrequency["CUSTOM"] = "custom";
+})(HabitFrequency || (exports.HabitFrequency = HabitFrequency = {}));
+var HabitEntryStatus;
+(function (HabitEntryStatus) {
+    HabitEntryStatus["COMPLETED"] = "completed";
+    HabitEntryStatus["EXCUSED"] = "excused";
+    HabitEntryStatus["MISSED"] = "missed";
+})(HabitEntryStatus || (exports.HabitEntryStatus = HabitEntryStatus = {}));
+exports.habitEntrySchema = zod_1.z.object({
+    _id: id_types_1.habitEntryIdSchema,
+    habitId: id_types_1.habitIdSchema,
+    userId: id_types_1.userIdSchema,
+    date: misc_types_1.dateOnlyStringSchema,
+    status: zod_1.z.nativeEnum(HabitEntryStatus),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date()
+});
+exports.habitDataSchema = zod_1.z.object({
+    _id: id_types_1.habitIdSchema,
+    userId: id_types_1.userIdSchema,
+    name: zod_1.z.string(),
+    description: zod_1.z.string().nullable().optional(),
+    notes: zod_1.z.string().nullable().optional(),
+    frequency: zod_1.z.nativeEnum(HabitFrequency),
+    rolloverTime: zod_1.z.string(),
+    firstDay: misc_types_1.dateOnlyStringSchema,
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date()
+});
+exports.habitStatsSchema = zod_1.z.object({
+    totalDays: zod_1.z.number(),
+    completedDays: zod_1.z.number(),
+    excusedDays: zod_1.z.number(),
+    missedDays: zod_1.z.number(),
+    completionRate: zod_1.z.number()
+});
+exports.habitSchema = exports.habitDataSchema.extend({
+    entries: zod_1.z.array(exports.habitEntrySchema),
+    stats: exports.habitStatsSchema
+});
+exports.createHabitRequestSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1).trim(),
+    description: zod_1.z.string().trim().optional(),
+    notes: zod_1.z.string().trim().optional(),
+    frequency: zod_1.z.nativeEnum(HabitFrequency),
+    rolloverTime: zod_1.z.string().regex(/^([01]?[0-9]|2[0-3]):[0-5][0-9]$/)
+});
+exports.updateHabitRequestSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1).trim().optional(),
+    description: zod_1.z.string().trim().nullish(),
+    notes: zod_1.z.string().trim().nullish(),
+    frequency: zod_1.z.nativeEnum(HabitFrequency).optional(),
+    rolloverTime: zod_1.z.string().regex(/^([01]?[0-9]|2[0-3]):[0-5][0-9]$/).optional()
+});
+exports.createHabitEntryRequestSchema = zod_1.z.object({
+    date: misc_types_1.dateOnlyStringSchema,
+    status: zod_1.z.nativeEnum(HabitEntryStatus)
+});

package/dist/types/new/index.d.ts

@@ -0,0 +1,10 @@
+export * from './agenda-types';
+export * from './thoughts-types';
+export * from './habits-types';
+export * from './people-types';
+export * from './lists-types';
+export * from './notifications-types';
+export * from './auth-types';
+export * from './user-types';
+export * from './program-config-types';
+export * from './misc';

package/dist/types/new/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./agenda-types"), exports);
+__exportStar(require("./thoughts-types"), exports);
+__exportStar(require("./habits-types"), exports);
+__exportStar(require("./people-types"), exports);
+__exportStar(require("./lists-types"), exports);
+__exportStar(require("./notifications-types"), exports);
+__exportStar(require("./auth-types"), exports);
+__exportStar(require("./user-types"), exports);
+__exportStar(require("./program-config-types"), exports);
+__exportStar(require("./misc"), exports);

package/dist/types/new/lists-types.d.ts

@@ -0,0 +1,164 @@
+import { z } from 'zod';
+import { Serialized } from '../../utils';
+export declare enum ListType {
+    TASKS = "tasks",
+    NOTES = "notes"
+}
+export declare const listItemSchema: z.ZodObject<{
+    _id: z.ZodEffects<z.ZodString, import("../id-types").ListItemId, string>;
+    userId: z.ZodEffects<z.ZodString, import("../id-types").UserId, string>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    name: z.ZodString;
+    notes: z.ZodOptional<z.ZodString>;
+    completed: z.ZodBoolean;
+    listId: z.ZodEffects<z.ZodString, import("../id-types").ListId, string>;
+}, "strip", z.ZodTypeAny, {
+    _id: string & {
+        readonly __brand: "ListItemId";
+    };
+    createdAt: Date;
+    updatedAt: Date;
+    userId: string & {
+        readonly __brand: "UserId";
+    };
+    name: string;
+    completed: boolean;
+    listId: string & {
+        readonly __brand: "ListId";
+    };
+    notes?: string | undefined;
+}, {
+    _id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    userId: string;
+    name: string;
+    completed: boolean;
+    listId: string;
+    notes?: string | undefined;
+}>;
+export declare const listSchema: z.ZodObject<{
+    _id: z.ZodEffects<z.ZodString, import("../id-types").ListId, string>;
+    userId: z.ZodEffects<z.ZodString, import("../id-types").UserId, string>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    name: z.ZodString;
+    type: z.ZodNativeEnum<typeof ListType>;
+}, "strip", z.ZodTypeAny, {
+    _id: string & {
+        readonly __brand: "ListId";
+    };
+    createdAt: Date;
+    updatedAt: Date;
+    userId: string & {
+        readonly __brand: "UserId";
+    };
+    type: ListType;
+    name: string;
+}, {
+    _id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    userId: string;
+    type: ListType;
+    name: string;
+}>;
+export declare const createListRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodNativeEnum<typeof ListType>;
+}, "strip", z.ZodTypeAny, {
+    type: ListType;
+    name: string;
+}, {
+    type: ListType;
+    name: string;
+}>;
+export declare const updateListRequestSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodNativeEnum<typeof ListType>>;
+}, "strip", z.ZodTypeAny, {
+    type?: ListType | undefined;
+    name?: string | undefined;
+}, {
+    type?: ListType | undefined;
+    name?: string | undefined;
+}>;
+export declare const createListItemRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    notes: z.ZodOptional<z.ZodString>;
+    listId: z.ZodEffects<z.ZodString, import("../id-types").ListId, string>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    listId: string & {
+        readonly __brand: "ListId";
+    };
+    notes?: string | undefined;
+}, {
+    name: string;
+    listId: string;
+    notes?: string | undefined;
+}>;
+export declare const updateListItemRequestSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    completed: z.ZodOptional<z.ZodBoolean>;
+    listId: z.ZodOptional<z.ZodEffects<z.ZodString, import("../id-types").ListId, string>>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    notes?: string | null | undefined;
+    completed?: boolean | undefined;
+    listId?: import("../id-types").ListId | undefined;
+}, {
+    name?: string | undefined;
+    notes?: string | null | undefined;
+    completed?: boolean | undefined;
+    listId?: string | undefined;
+}>;
+export declare const completeListItemRequestSchema: z.ZodObject<{
+    completed: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    completed: boolean;
+}, {
+    completed: boolean;
+}>;
+export type ListItemData = z.infer<typeof listItemSchema>;
+export type ListData = z.infer<typeof listSchema>;
+export type CreateListRequest = z.infer<typeof createListRequestSchema>;
+export type UpdateListRequest = z.infer<typeof updateListRequestSchema>;
+export type CreateListItemRequest = z.infer<typeof createListItemRequestSchema>;
+export type UpdateListItemRequest = z.infer<typeof updateListItemRequestSchema>;
+export type CompleteListItemRequest = z.infer<typeof completeListItemRequestSchema>;
+export interface CreateListResponse {
+    list: Serialized<ListData>;
+}
+export interface GetListsResponse {
+    lists: Serialized<ListData>[];
+}
+export interface GetListResponse {
+    list: Serialized<ListData>;
+}
+export interface UpdateListResponse {
+    list: Serialized<ListData>;
+}
+export interface DeleteListResponse {
+    deleted: boolean;
+}
+export interface CreateListItemResponse {
+    listItem: Serialized<ListItemData>;
+}
+export interface GetListItemsResponse {
+    listItems: Serialized<ListItemData>[];
+}
+export interface GetListItemResponse {
+    listItem: Serialized<ListItemData>;
+}
+export interface UpdateListItemResponse {
+    listItem: Serialized<ListItemData>;
+}
+export interface CompleteListItemResponse {
+    listItem: Serialized<ListItemData>;
+}
+export interface DeleteListItemResponse {
+    deleted: boolean;
+}

package/dist/types/new/lists-types.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completeListItemRequestSchema = exports.updateListItemRequestSchema = exports.createListItemRequestSchema = exports.updateListRequestSchema = exports.createListRequestSchema = exports.listSchema = exports.listItemSchema = exports.ListType = void 0;
+const zod_1 = require("zod");
+const id_types_1 = require("../id-types");
+var ListType;
+(function (ListType) {
+    ListType["TASKS"] = "tasks";
+    ListType["NOTES"] = "notes";
+})(ListType || (exports.ListType = ListType = {}));
+exports.listItemSchema = zod_1.z.object({
+    _id: id_types_1.listItemIdSchema,
+    userId: id_types_1.userIdSchema,
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+    name: zod_1.z.string(),
+    notes: zod_1.z.string().optional(),
+    completed: zod_1.z.boolean(),
+    listId: id_types_1.listIdSchema
+});
+exports.listSchema = zod_1.z.object({
+    _id: id_types_1.listIdSchema,
+    userId: id_types_1.userIdSchema,
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+    name: zod_1.z.string(),
+    type: zod_1.z.nativeEnum(ListType)
+});
+exports.createListRequestSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1),
+    type: zod_1.z.nativeEnum(ListType)
+});
+exports.updateListRequestSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1).optional(),
+    type: zod_1.z.nativeEnum(ListType).optional()
+});
+exports.createListItemRequestSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1),
+    notes: zod_1.z.string().optional(),
+    listId: id_types_1.listIdSchema
+});
+exports.updateListItemRequestSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1).optional(),
+    notes: zod_1.z.string().nullish(),
+    completed: zod_1.z.boolean().optional(),
+    listId: id_types_1.listIdSchema.optional()
+});
+exports.completeListItemRequestSchema = zod_1.z.object({
+    completed: zod_1.z.boolean()
+});

package/dist/types/new/misc/index.d.ts

@@ -0,0 +1 @@
+export * from './version-types';

package/dist/types/new/misc/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./version-types"), exports);

package/dist/types/new/misc/version-types.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export declare const versionQuerySchema: z.ZodObject<{
+    iOSBuildVersion: z.ZodOptional<z.ZodNumber>;
+    androidBuildVersion: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    iOSBuildVersion?: number | undefined;
+    androidBuildVersion?: number | undefined;
+}, {
+    iOSBuildVersion?: number | undefined;
+    androidBuildVersion?: number | undefined;
+}>;
+export declare const versionResponseSchema: z.ZodObject<{
+    minIOSBuildVersion: z.ZodNumber;
+    minAndroidBuildVersion: z.ZodNumber;
+    updateRequired: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    minIOSBuildVersion: number;
+    minAndroidBuildVersion: number;
+    updateRequired: boolean;
+}, {
+    minIOSBuildVersion: number;
+    minAndroidBuildVersion: number;
+    updateRequired: boolean;
+}>;
+export type VersionQuery = z.infer<typeof versionQuerySchema>;
+export type VersionResponse = z.infer<typeof versionResponseSchema>;