@cossistant/core 0.0.25 → 0.0.28

package/typing-reporter.d.ts

@@ -0,0 +1,71 @@
+//#region src/typing-reporter.d.ts
+/**
+ * Shared typing reporter logic for throttling and scheduling typing events.
+ * This is a framework-agnostic utility used by both React widget and dashboard hooks.
+ */
+/** Minimum interval between typing event sends (ms) */
+declare const TYPING_SEND_INTERVAL_MS = 800;
+/** Keep-alive interval for typing events (ms) */
+declare const TYPING_KEEP_ALIVE_MS = 4000;
+/** Delay before auto-stop typing on inactivity (ms) */
+declare const TYPING_STOP_DELAY_MS = 2000;
+/** Maximum length for typing preview text */
+declare const TYPING_PREVIEW_MAX_LENGTH = 2000;
+type TypingReporterState = {
+  isActive: boolean;
+  lastSentAt: number;
+  latestPreview: string;
+};
+type TypingReporterSendFn = (isTyping: boolean, preview?: string | null) => void | Promise<void>;
+type TypingReporterConfig = {
+  /** Function to send the typing event */
+  send: TypingReporterSendFn;
+  /** Custom send interval (default: 800ms) */
+  sendIntervalMs?: number;
+  /** Custom keep-alive interval (default: 4000ms) */
+  keepAliveMs?: number;
+  /** Custom stop delay (default: 2000ms) */
+  stopDelayMs?: number;
+  /** Maximum preview length (default: 2000) */
+  previewMaxLength?: number;
+  /** Whether to include preview text (default: true) */
+  includePreview?: boolean;
+};
+type TypingReporter = {
+  /** Call when input value changes */
+  handleInputChange: (value: string) => void;
+  /** Call when message is submitted */
+  handleSubmit: () => void;
+  /** Force stop typing indicator */
+  stop: () => void;
+  /** Clean up timers (call on unmount) */
+  dispose: () => void;
+  /** Get current state (for testing) */
+  getState: () => TypingReporterState;
+};
+/**
+ * Creates a typing reporter instance that handles throttling and scheduling
+ * of typing events.
+ *
+ * @example
+ * ```ts
+ * const reporter = createTypingReporter({
+ *   send: async (isTyping, preview) => {
+ *     await api.sendTypingEvent({ isTyping, preview });
+ *   },
+ * });
+ *
+ * // On input change
+ * reporter.handleInputChange(inputValue);
+ *
+ * // On submit
+ * reporter.handleSubmit();
+ *
+ * // On unmount
+ * reporter.dispose();
+ * ```
+ */
+declare function createTypingReporter(config: TypingReporterConfig): TypingReporter;
+//#endregion
+export { TYPING_KEEP_ALIVE_MS, TYPING_PREVIEW_MAX_LENGTH, TYPING_SEND_INTERVAL_MS, TYPING_STOP_DELAY_MS, TypingReporter, TypingReporterConfig, createTypingReporter };
+//# sourceMappingURL=typing-reporter.d.ts.map

package/typing-reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typing-reporter.d.ts","names":[],"sources":["../src/typing-reporter.ts"],"sourcesContent":[],"mappings":";;AAMA;AAGA;AAGA;AAGA;AAEK,cAXQ,uBAAA,GAWW,GAAA;AAAA;AAgBZ,cAxBC,oBAAA,GA0BN,IAAA;AAaP;AAmCgB,cAvEH,oBAAA,GAwEJ,IAAA;;cArEI,yBAAA;KAER,mBAAA;;;;;KAWA,oBAAA,0DAGO;KAEA,oBAAA;;QAEL;;;;;;;;;;;;KAaK,cAAA;;;;;;;;;;kBAUK;;;;;;;;;;;;;;;;;;;;;;;;iBAyBD,oBAAA,SACP,uBACN"}

package/typing-reporter.js

@@ -0,0 +1,145 @@
+//#region src/typing-reporter.ts
+/**
+* Shared typing reporter logic for throttling and scheduling typing events.
+* This is a framework-agnostic utility used by both React widget and dashboard hooks.
+*/
+/** Minimum interval between typing event sends (ms) */
+const TYPING_SEND_INTERVAL_MS = 800;
+/** Keep-alive interval for typing events (ms) */
+const TYPING_KEEP_ALIVE_MS = 4e3;
+/** Delay before auto-stop typing on inactivity (ms) */
+const TYPING_STOP_DELAY_MS = 2e3;
+/** Maximum length for typing preview text */
+const TYPING_PREVIEW_MAX_LENGTH = 2e3;
+/**
+* Creates a typing reporter instance that handles throttling and scheduling
+* of typing events.
+*
+* @example
+* ```ts
+* const reporter = createTypingReporter({
+*   send: async (isTyping, preview) => {
+*     await api.sendTypingEvent({ isTyping, preview });
+*   },
+* });
+*
+* // On input change
+* reporter.handleInputChange(inputValue);
+*
+* // On submit
+* reporter.handleSubmit();
+*
+* // On unmount
+* reporter.dispose();
+* ```
+*/
+function createTypingReporter(config) {
+	const { send, sendIntervalMs = TYPING_SEND_INTERVAL_MS, keepAliveMs = TYPING_KEEP_ALIVE_MS, stopDelayMs = TYPING_STOP_DELAY_MS, previewMaxLength = TYPING_PREVIEW_MAX_LENGTH, includePreview = true } = config;
+	const state = {
+		isActive: false,
+		lastSentAt: 0,
+		latestPreview: ""
+	};
+	const timers = {
+		keepAlive: null,
+		stopTyping: null
+	};
+	const clearKeepAlive = () => {
+		if (timers.keepAlive) {
+			clearTimeout(timers.keepAlive);
+			timers.keepAlive = null;
+		}
+	};
+	const clearStopTypingTimeout = () => {
+		if (timers.stopTyping) {
+			clearTimeout(timers.stopTyping);
+			timers.stopTyping = null;
+		}
+	};
+	const sendTyping = (isTyping) => {
+		const preview = includePreview && isTyping ? state.latestPreview : null;
+		Promise.resolve(send(isTyping, preview)).catch((error) => {
+			console.error("[TypingReporter] Failed to send typing event", error);
+		});
+	};
+	const scheduleKeepAlive = () => {
+		clearKeepAlive();
+		timers.keepAlive = setTimeout(() => {
+			if (state.isActive) {
+				sendTyping(true);
+				scheduleKeepAlive();
+			}
+		}, keepAliveMs);
+	};
+	const scheduleStopTyping = () => {
+		clearStopTypingTimeout();
+		timers.stopTyping = setTimeout(() => {
+			if (state.isActive) {
+				state.isActive = false;
+				clearKeepAlive();
+				sendTyping(false);
+			}
+		}, stopDelayMs);
+	};
+	const handleInputChange = (value) => {
+		const trimmed = value.trim();
+		state.latestPreview = trimmed.slice(0, previewMaxLength);
+		const now = typeof globalThis !== "undefined" && "Date" in globalThis ? Date.now() : 0;
+		if (trimmed.length === 0) {
+			if (state.isActive) {
+				state.isActive = false;
+				state.lastSentAt = now;
+				clearKeepAlive();
+				clearStopTypingTimeout();
+				sendTyping(false);
+			}
+			return;
+		}
+		scheduleStopTyping();
+		if (!state.isActive) {
+			state.isActive = true;
+			state.lastSentAt = now;
+			sendTyping(true);
+			scheduleKeepAlive();
+			return;
+		}
+		if (now - state.lastSentAt >= sendIntervalMs) {
+			state.lastSentAt = now;
+			sendTyping(true);
+			scheduleKeepAlive();
+		}
+	};
+	const handleSubmit = () => {
+		if (!state.isActive) return;
+		state.isActive = false;
+		state.lastSentAt = typeof globalThis !== "undefined" && "Date" in globalThis ? Date.now() : 0;
+		clearKeepAlive();
+		clearStopTypingTimeout();
+		sendTyping(false);
+	};
+	const stop = () => {
+		if (!state.isActive) return;
+		state.isActive = false;
+		state.lastSentAt = typeof globalThis !== "undefined" && "Date" in globalThis ? Date.now() : 0;
+		clearKeepAlive();
+		clearStopTypingTimeout();
+		sendTyping(false);
+	};
+	const dispose = () => {
+		if (state.isActive) sendTyping(false);
+		clearKeepAlive();
+		clearStopTypingTimeout();
+	};
+	const getState = () => ({ ...state });
+	return {
+		handleInputChange,
+		handleSubmit,
+		stop,
+		dispose,
+		getState
+	};
+}
+
+//#endregion
+export { TYPING_KEEP_ALIVE_MS, TYPING_PREVIEW_MAX_LENGTH, TYPING_SEND_INTERVAL_MS, TYPING_STOP_DELAY_MS, createTypingReporter };
+//# sourceMappingURL=typing-reporter.js.map

package/typing-reporter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typing-reporter.js","names":["state: TypingReporterState","timers: TypingReporterTimers"],"sources":["../src/typing-reporter.ts"],"sourcesContent":["/**\n * Shared typing reporter logic for throttling and scheduling typing events.\n * This is a framework-agnostic utility used by both React widget and dashboard hooks.\n */\n\n/** Minimum interval between typing event sends (ms) */\nexport const TYPING_SEND_INTERVAL_MS = 800;\n\n/** Keep-alive interval for typing events (ms) */\nexport const TYPING_KEEP_ALIVE_MS = 4000;\n\n/** Delay before auto-stop typing on inactivity (ms) */\nexport const TYPING_STOP_DELAY_MS = 2000;\n\n/** Maximum length for typing preview text */\nexport const TYPING_PREVIEW_MAX_LENGTH = 2000;\n\ntype TypingReporterState = {\n\tisActive: boolean;\n\tlastSentAt: number;\n\tlatestPreview: string;\n};\n\ntype TypingReporterTimers = {\n\tkeepAlive: ReturnType<typeof setTimeout> | null;\n\tstopTyping: ReturnType<typeof setTimeout> | null;\n};\n\ntype TypingReporterSendFn = (\n\tisTyping: boolean,\n\tpreview?: string | null\n) => void | Promise<void>;\n\nexport type TypingReporterConfig = {\n\t/** Function to send the typing event */\n\tsend: TypingReporterSendFn;\n\t/** Custom send interval (default: 800ms) */\n\tsendIntervalMs?: number;\n\t/** Custom keep-alive interval (default: 4000ms) */\n\tkeepAliveMs?: number;\n\t/** Custom stop delay (default: 2000ms) */\n\tstopDelayMs?: number;\n\t/** Maximum preview length (default: 2000) */\n\tpreviewMaxLength?: number;\n\t/** Whether to include preview text (default: true) */\n\tincludePreview?: boolean;\n};\n\nexport type TypingReporter = {\n\t/** Call when input value changes */\n\thandleInputChange: (value: string) => void;\n\t/** Call when message is submitted */\n\thandleSubmit: () => void;\n\t/** Force stop typing indicator */\n\tstop: () => void;\n\t/** Clean up timers (call on unmount) */\n\tdispose: () => void;\n\t/** Get current state (for testing) */\n\tgetState: () => TypingReporterState;\n};\n\n/**\n * Creates a typing reporter instance that handles throttling and scheduling\n * of typing events.\n *\n * @example\n * ```ts\n * const reporter = createTypingReporter({\n *   send: async (isTyping, preview) => {\n *     await api.sendTypingEvent({ isTyping, preview });\n *   },\n * });\n *\n * // On input change\n * reporter.handleInputChange(inputValue);\n *\n * // On submit\n * reporter.handleSubmit();\n *\n * // On unmount\n * reporter.dispose();\n * ```\n */\nexport function createTypingReporter(\n\tconfig: TypingReporterConfig\n): TypingReporter {\n\tconst {\n\t\tsend,\n\t\tsendIntervalMs = TYPING_SEND_INTERVAL_MS,\n\t\tkeepAliveMs = TYPING_KEEP_ALIVE_MS,\n\t\tstopDelayMs = TYPING_STOP_DELAY_MS,\n\t\tpreviewMaxLength = TYPING_PREVIEW_MAX_LENGTH,\n\t\tincludePreview = true,\n\t} = config;\n\n\tconst state: TypingReporterState = {\n\t\tisActive: false,\n\t\tlastSentAt: 0,\n\t\tlatestPreview: \"\",\n\t};\n\n\tconst timers: TypingReporterTimers = {\n\t\tkeepAlive: null,\n\t\tstopTyping: null,\n\t};\n\n\tconst clearKeepAlive = () => {\n\t\tif (timers.keepAlive) {\n\t\t\tclearTimeout(timers.keepAlive);\n\t\t\ttimers.keepAlive = null;\n\t\t}\n\t};\n\n\tconst clearStopTypingTimeout = () => {\n\t\tif (timers.stopTyping) {\n\t\t\tclearTimeout(timers.stopTyping);\n\t\t\ttimers.stopTyping = null;\n\t\t}\n\t};\n\n\tconst sendTyping = (isTyping: boolean) => {\n\t\tconst preview = includePreview && isTyping ? state.latestPreview : null;\n\t\tvoid Promise.resolve(send(isTyping, preview)).catch((error) => {\n\t\t\tconsole.error(\"[TypingReporter] Failed to send typing event\", error);\n\t\t});\n\t};\n\n\tconst scheduleKeepAlive = () => {\n\t\tclearKeepAlive();\n\t\ttimers.keepAlive = setTimeout(() => {\n\t\t\tif (state.isActive) {\n\t\t\t\tsendTyping(true);\n\t\t\t\tscheduleKeepAlive();\n\t\t\t}\n\t\t}, keepAliveMs);\n\t};\n\n\tconst scheduleStopTyping = () => {\n\t\tclearStopTypingTimeout();\n\t\ttimers.stopTyping = setTimeout(() => {\n\t\t\tif (state.isActive) {\n\t\t\t\tstate.isActive = false;\n\t\t\t\tclearKeepAlive();\n\t\t\t\tsendTyping(false);\n\t\t\t}\n\t\t}, stopDelayMs);\n\t};\n\n\tconst handleInputChange = (value: string) => {\n\t\tconst trimmed = value.trim();\n\t\tstate.latestPreview = trimmed.slice(0, previewMaxLength);\n\t\tconst now =\n\t\t\ttypeof globalThis !== \"undefined\" && \"Date\" in globalThis\n\t\t\t\t? Date.now()\n\t\t\t\t: 0;\n\n\t\tif (trimmed.length === 0) {\n\t\t\tif (state.isActive) {\n\t\t\t\tstate.isActive = false;\n\t\t\t\tstate.lastSentAt = now;\n\t\t\t\tclearKeepAlive();\n\t\t\t\tclearStopTypingTimeout();\n\t\t\t\tsendTyping(false);\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\n\t\t// Schedule auto-stop after inactivity\n\t\tscheduleStopTyping();\n\n\t\tif (!state.isActive) {\n\t\t\tstate.isActive = true;\n\t\t\tstate.lastSentAt = now;\n\t\t\tsendTyping(true);\n\t\t\tscheduleKeepAlive();\n\t\t\treturn;\n\t\t}\n\n\t\tif (now - state.lastSentAt >= sendIntervalMs) {\n\t\t\tstate.lastSentAt = now;\n\t\t\tsendTyping(true);\n\t\t\tscheduleKeepAlive();\n\t\t}\n\t};\n\n\tconst handleSubmit = () => {\n\t\tif (!state.isActive) {\n\t\t\treturn;\n\t\t}\n\n\t\tstate.isActive = false;\n\t\tstate.lastSentAt =\n\t\t\ttypeof globalThis !== \"undefined\" && \"Date\" in globalThis\n\t\t\t\t? Date.now()\n\t\t\t\t: 0;\n\t\tclearKeepAlive();\n\t\tclearStopTypingTimeout();\n\t\tsendTyping(false);\n\t};\n\n\tconst stop = () => {\n\t\tif (!state.isActive) {\n\t\t\treturn;\n\t\t}\n\n\t\tstate.isActive = false;\n\t\tstate.lastSentAt =\n\t\t\ttypeof globalThis !== \"undefined\" && \"Date\" in globalThis\n\t\t\t\t? Date.now()\n\t\t\t\t: 0;\n\t\tclearKeepAlive();\n\t\tclearStopTypingTimeout();\n\t\tsendTyping(false);\n\t};\n\n\tconst dispose = () => {\n\t\tif (state.isActive) {\n\t\t\tsendTyping(false);\n\t\t}\n\t\tclearKeepAlive();\n\t\tclearStopTypingTimeout();\n\t};\n\n\tconst getState = () => ({ ...state });\n\n\treturn {\n\t\thandleInputChange,\n\t\thandleSubmit,\n\t\tstop,\n\t\tdispose,\n\t\tgetState,\n\t};\n}\n"],"mappings":";;;;;;AAMA,MAAa,0BAA0B;;AAGvC,MAAa,uBAAuB;;AAGpC,MAAa,uBAAuB;;AAGpC,MAAa,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;AAoEzC,SAAgB,qBACf,QACiB;CACjB,MAAM,EACL,MACA,iBAAiB,yBACjB,cAAc,sBACd,cAAc,sBACd,mBAAmB,2BACnB,iBAAiB,SACd;CAEJ,MAAMA,QAA6B;EAClC,UAAU;EACV,YAAY;EACZ,eAAe;EACf;CAED,MAAMC,SAA+B;EACpC,WAAW;EACX,YAAY;EACZ;CAED,MAAM,uBAAuB;AAC5B,MAAI,OAAO,WAAW;AACrB,gBAAa,OAAO,UAAU;AAC9B,UAAO,YAAY;;;CAIrB,MAAM,+BAA+B;AACpC,MAAI,OAAO,YAAY;AACtB,gBAAa,OAAO,WAAW;AAC/B,UAAO,aAAa;;;CAItB,MAAM,cAAc,aAAsB;EACzC,MAAM,UAAU,kBAAkB,WAAW,MAAM,gBAAgB;AACnE,EAAK,QAAQ,QAAQ,KAAK,UAAU,QAAQ,CAAC,CAAC,OAAO,UAAU;AAC9D,WAAQ,MAAM,gDAAgD,MAAM;IACnE;;CAGH,MAAM,0BAA0B;AAC/B,kBAAgB;AAChB,SAAO,YAAY,iBAAiB;AACnC,OAAI,MAAM,UAAU;AACnB,eAAW,KAAK;AAChB,uBAAmB;;KAElB,YAAY;;CAGhB,MAAM,2BAA2B;AAChC,0BAAwB;AACxB,SAAO,aAAa,iBAAiB;AACpC,OAAI,MAAM,UAAU;AACnB,UAAM,WAAW;AACjB,oBAAgB;AAChB,eAAW,MAAM;;KAEhB,YAAY;;CAGhB,MAAM,qBAAqB,UAAkB;EAC5C,MAAM,UAAU,MAAM,MAAM;AAC5B,QAAM,gBAAgB,QAAQ,MAAM,GAAG,iBAAiB;EACxD,MAAM,MACL,OAAO,eAAe,eAAe,UAAU,aAC5C,KAAK,KAAK,GACV;AAEJ,MAAI,QAAQ,WAAW,GAAG;AACzB,OAAI,MAAM,UAAU;AACnB,UAAM,WAAW;AACjB,UAAM,aAAa;AACnB,oBAAgB;AAChB,4BAAwB;AACxB,eAAW,MAAM;;AAElB;;AAID,sBAAoB;AAEpB,MAAI,CAAC,MAAM,UAAU;AACpB,SAAM,WAAW;AACjB,SAAM,aAAa;AACnB,cAAW,KAAK;AAChB,sBAAmB;AACnB;;AAGD,MAAI,MAAM,MAAM,cAAc,gBAAgB;AAC7C,SAAM,aAAa;AACnB,cAAW,KAAK;AAChB,sBAAmB;;;CAIrB,MAAM,qBAAqB;AAC1B,MAAI,CAAC,MAAM,SACV;AAGD,QAAM,WAAW;AACjB,QAAM,aACL,OAAO,eAAe,eAAe,UAAU,aAC5C,KAAK,KAAK,GACV;AACJ,kBAAgB;AAChB,0BAAwB;AACxB,aAAW,MAAM;;CAGlB,MAAM,aAAa;AAClB,MAAI,CAAC,MAAM,SACV;AAGD,QAAM,WAAW;AACjB,QAAM,aACL,OAAO,eAAe,eAAe,UAAU,aAC5C,KAAK,KAAK,GACV;AACJ,kBAAgB;AAChB,0BAAwB;AACxB,aAAW,MAAM;;CAGlB,MAAM,gBAAgB;AACrB,MAAI,MAAM,SACT,YAAW,MAAM;AAElB,kBAAgB;AAChB,0BAAwB;;CAGzB,MAAM,kBAAkB,EAAE,GAAG,OAAO;AAEpC,QAAO;EACN;EACA;EACA;EACA;EACA;EACA"}

package/upload-constants.d.ts

@@ -0,0 +1,40 @@
+//#region src/upload-constants.d.ts
+/**
+ * File upload constants for cost/API protection.
+ * These limits are enforced on both client and server side.
+ */
+/** Maximum file size in bytes (5 MB) */
+declare const MAX_FILE_SIZE: number;
+/** Maximum number of files per message */
+declare const MAX_FILES_PER_MESSAGE = 3;
+/** Allowed MIME types for file uploads */
+declare const ALLOWED_MIME_TYPES: readonly ["image/jpeg", "image/png", "image/gif", "image/webp", "application/pdf", "text/plain", "text/csv", "text/markdown", "application/zip"];
+/** Human-readable file type descriptions for error messages */
+declare const ALLOWED_FILE_TYPES_DESCRIPTION = "images (JPEG, PNG, GIF, WebP), PDF, text files (TXT, CSV, MD), and ZIP archives";
+/** Accept string for file input elements */
+declare const FILE_INPUT_ACCEPT: string;
+/**
+ * Check if a MIME type is allowed for upload
+ */
+declare function isAllowedMimeType(mimeType: string): boolean;
+/**
+ * Check if a file is an image based on MIME type
+ */
+declare function isImageMimeType(mimeType: string): boolean;
+/**
+ * Format file size for display
+ */
+declare function formatFileSize(bytes: number): string;
+/**
+ * Validate a file against upload constraints
+ * @returns null if valid, error message if invalid
+ */
+declare function validateFile(file: File): string | null;
+/**
+ * Validate multiple files against upload constraints
+ * @returns null if all valid, error message if any invalid
+ */
+declare function validateFiles(files: File[]): string | null;
+//#endregion
+export { ALLOWED_FILE_TYPES_DESCRIPTION, ALLOWED_MIME_TYPES, FILE_INPUT_ACCEPT, MAX_FILES_PER_MESSAGE, MAX_FILE_SIZE, formatFileSize, isAllowedMimeType, isImageMimeType, validateFile, validateFiles };
+//# sourceMappingURL=upload-constants.d.ts.map

package/upload-constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload-constants.d.ts","names":[],"sources":["../src/upload-constants.ts"],"sourcesContent":[],"mappings":";;AAMA;AAGA;AAGA;AAiBA;AAIa,cA3BA,aA2BgD,EAAA,MAAA;AAK7D;AAOgB,cApCH,qBAAA,GAoCkB,CAAA;AAO/B;AAcgB,cAtDH,kBAsD0B,EAAA,SAAA,CAAA,YAAA,EAAA,WAAA,EAAA,WAAA,EAAA,YAAA,EAAA,iBAAA,EAAA,YAAA,EAAA,UAAA,EAAA,eAAA,EAAA,iBAAA,CAAA;AAgBvC;cArDa,8BAAA;;cAIA;;;;iBAKG,iBAAA;;;;iBAOA,eAAA;;;;iBAOA,cAAA;;;;;iBAcA,YAAA,OAAmB;;;;;iBAgBnB,aAAA,QAAqB"}

package/upload-constants.js

@@ -0,0 +1,70 @@
+//#region src/upload-constants.ts
+/**
+* File upload constants for cost/API protection.
+* These limits are enforced on both client and server side.
+*/
+/** Maximum file size in bytes (5 MB) */
+const MAX_FILE_SIZE = 5 * 1024 * 1024;
+/** Maximum number of files per message */
+const MAX_FILES_PER_MESSAGE = 3;
+/** Allowed MIME types for file uploads */
+const ALLOWED_MIME_TYPES = [
+	"image/jpeg",
+	"image/png",
+	"image/gif",
+	"image/webp",
+	"application/pdf",
+	"text/plain",
+	"text/csv",
+	"text/markdown",
+	"application/zip"
+];
+/** Human-readable file type descriptions for error messages */
+const ALLOWED_FILE_TYPES_DESCRIPTION = "images (JPEG, PNG, GIF, WebP), PDF, text files (TXT, CSV, MD), and ZIP archives";
+/** Accept string for file input elements */
+const FILE_INPUT_ACCEPT = ALLOWED_MIME_TYPES.join(",");
+/**
+* Check if a MIME type is allowed for upload
+*/
+function isAllowedMimeType(mimeType) {
+	return ALLOWED_MIME_TYPES.includes(mimeType);
+}
+/**
+* Check if a file is an image based on MIME type
+*/
+function isImageMimeType(mimeType) {
+	return mimeType.startsWith("image/");
+}
+/**
+* Format file size for display
+*/
+function formatFileSize(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+/**
+* Validate a file against upload constraints
+* @returns null if valid, error message if invalid
+*/
+function validateFile(file) {
+	if (file.size > MAX_FILE_SIZE) return `File "${file.name}" exceeds maximum size of ${formatFileSize(MAX_FILE_SIZE)}`;
+	if (!isAllowedMimeType(file.type)) return `File type "${file.type || "unknown"}" is not allowed. Allowed types: ${ALLOWED_FILE_TYPES_DESCRIPTION}`;
+	return null;
+}
+/**
+* Validate multiple files against upload constraints
+* @returns null if all valid, error message if any invalid
+*/
+function validateFiles(files) {
+	if (files.length > MAX_FILES_PER_MESSAGE) return `Cannot attach more than ${MAX_FILES_PER_MESSAGE} files per message`;
+	for (const file of files) {
+		const error = validateFile(file);
+		if (error) return error;
+	}
+	return null;
+}
+
+//#endregion
+export { ALLOWED_FILE_TYPES_DESCRIPTION, ALLOWED_MIME_TYPES, FILE_INPUT_ACCEPT, MAX_FILES_PER_MESSAGE, MAX_FILE_SIZE, formatFileSize, isAllowedMimeType, isImageMimeType, validateFile, validateFiles };
+//# sourceMappingURL=upload-constants.js.map

package/upload-constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload-constants.js","names":[],"sources":["../src/upload-constants.ts"],"sourcesContent":["/**\n * File upload constants for cost/API protection.\n * These limits are enforced on both client and server side.\n */\n\n/** Maximum file size in bytes (5 MB) */\nexport const MAX_FILE_SIZE = 5 * 1024 * 1024;\n\n/** Maximum number of files per message */\nexport const MAX_FILES_PER_MESSAGE = 3;\n\n/** Allowed MIME types for file uploads */\nexport const ALLOWED_MIME_TYPES = [\n\t// Images\n\t\"image/jpeg\",\n\t\"image/png\",\n\t\"image/gif\",\n\t\"image/webp\",\n\t// Documents\n\t\"application/pdf\",\n\t// Text files\n\t\"text/plain\",\n\t\"text/csv\",\n\t\"text/markdown\",\n\t// Archives\n\t\"application/zip\",\n] as const;\n\n/** Human-readable file type descriptions for error messages */\nexport const ALLOWED_FILE_TYPES_DESCRIPTION =\n\t\"images (JPEG, PNG, GIF, WebP), PDF, text files (TXT, CSV, MD), and ZIP archives\";\n\n/** Accept string for file input elements */\nexport const FILE_INPUT_ACCEPT = ALLOWED_MIME_TYPES.join(\",\");\n\n/**\n * Check if a MIME type is allowed for upload\n */\nexport function isAllowedMimeType(mimeType: string): boolean {\n\treturn (ALLOWED_MIME_TYPES as readonly string[]).includes(mimeType);\n}\n\n/**\n * Check if a file is an image based on MIME type\n */\nexport function isImageMimeType(mimeType: string): boolean {\n\treturn mimeType.startsWith(\"image/\");\n}\n\n/**\n * Format file size for display\n */\nexport function formatFileSize(bytes: number): string {\n\tif (bytes < 1024) {\n\t\treturn `${bytes} B`;\n\t}\n\tif (bytes < 1024 * 1024) {\n\t\treturn `${(bytes / 1024).toFixed(1)} KB`;\n\t}\n\treturn `${(bytes / (1024 * 1024)).toFixed(1)} MB`;\n}\n\n/**\n * Validate a file against upload constraints\n * @returns null if valid, error message if invalid\n */\nexport function validateFile(file: File): string | null {\n\tif (file.size > MAX_FILE_SIZE) {\n\t\treturn `File \"${file.name}\" exceeds maximum size of ${formatFileSize(MAX_FILE_SIZE)}`;\n\t}\n\n\tif (!isAllowedMimeType(file.type)) {\n\t\treturn `File type \"${file.type || \"unknown\"}\" is not allowed. Allowed types: ${ALLOWED_FILE_TYPES_DESCRIPTION}`;\n\t}\n\n\treturn null;\n}\n\n/**\n * Validate multiple files against upload constraints\n * @returns null if all valid, error message if any invalid\n */\nexport function validateFiles(files: File[]): string | null {\n\tif (files.length > MAX_FILES_PER_MESSAGE) {\n\t\treturn `Cannot attach more than ${MAX_FILES_PER_MESSAGE} files per message`;\n\t}\n\n\tfor (const file of files) {\n\t\tconst error = validateFile(file);\n\t\tif (error) {\n\t\t\treturn error;\n\t\t}\n\t}\n\n\treturn null;\n}\n"],"mappings":";;;;;;AAMA,MAAa,gBAAgB,IAAI,OAAO;;AAGxC,MAAa,wBAAwB;;AAGrC,MAAa,qBAAqB;CAEjC;CACA;CACA;CACA;CAEA;CAEA;CACA;CACA;CAEA;CACA;;AAGD,MAAa,iCACZ;;AAGD,MAAa,oBAAoB,mBAAmB,KAAK,IAAI;;;;AAK7D,SAAgB,kBAAkB,UAA2B;AAC5D,QAAQ,mBAAyC,SAAS,SAAS;;;;;AAMpE,SAAgB,gBAAgB,UAA2B;AAC1D,QAAO,SAAS,WAAW,SAAS;;;;;AAMrC,SAAgB,eAAe,OAAuB;AACrD,KAAI,QAAQ,KACX,QAAO,GAAG,MAAM;AAEjB,KAAI,QAAQ,OAAO,KAClB,QAAO,IAAI,QAAQ,MAAM,QAAQ,EAAE,CAAC;AAErC,QAAO,IAAI,SAAS,OAAO,OAAO,QAAQ,EAAE,CAAC;;;;;;AAO9C,SAAgB,aAAa,MAA2B;AACvD,KAAI,KAAK,OAAO,cACf,QAAO,SAAS,KAAK,KAAK,4BAA4B,eAAe,cAAc;AAGpF,KAAI,CAAC,kBAAkB,KAAK,KAAK,CAChC,QAAO,cAAc,KAAK,QAAQ,UAAU,mCAAmC;AAGhF,QAAO;;;;;;AAOR,SAAgB,cAAc,OAA8B;AAC3D,KAAI,MAAM,SAAS,sBAClB,QAAO,2BAA2B,sBAAsB;AAGzD,MAAK,MAAM,QAAQ,OAAO;EACzB,MAAM,QAAQ,aAAa,KAAK;AAChC,MAAI,MACH,QAAO;;AAIT,QAAO"}

package/upload.d.ts

@@ -0,0 +1,47 @@
+import { z } from "@hono/zod-openapi";
+
+//#region ../types/src/api/upload.d.ts
+
+declare const generateUploadUrlRequestSchema: z.ZodObject<{
+  contentType: z.ZodString;
+  websiteId: z.ZodString;
+  scope: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"conversation">;
+    conversationId: z.ZodString;
+    organizationId: z.ZodString;
+    websiteId: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"user">;
+    userId: z.ZodString;
+    organizationId: z.ZodString;
+    websiteId: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"contact">;
+    contactId: z.ZodString;
+    organizationId: z.ZodString;
+    websiteId: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"visitor">;
+    visitorId: z.ZodString;
+    organizationId: z.ZodString;
+    websiteId: z.ZodString;
+  }, z.core.$strip>], "type">;
+  path: z.ZodOptional<z.ZodString>;
+  fileName: z.ZodOptional<z.ZodString>;
+  fileExtension: z.ZodOptional<z.ZodString>;
+  useCdn: z.ZodOptional<z.ZodBoolean>;
+  expiresInSeconds: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type GenerateUploadUrlRequest = z.infer<typeof generateUploadUrlRequestSchema>;
+declare const generateUploadUrlResponseSchema: z.ZodObject<{
+  uploadUrl: z.ZodURL;
+  key: z.ZodString;
+  bucket: z.ZodString;
+  expiresAt: z.ZodString;
+  contentType: z.ZodString;
+  publicUrl: z.ZodURL;
+}, z.core.$strip>;
+type GenerateUploadUrlResponse = z.infer<typeof generateUploadUrlResponseSchema>;
+//#endregion
+export { GenerateUploadUrlRequest, GenerateUploadUrlResponse };
+//# sourceMappingURL=upload.d.ts.map

package/upload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload.d.ts","names":[],"sources":["../../types/src/api/upload.ts"],"sourcesContent":[],"mappings":";;;;AAkMY,cAvEC,8BAwEL,EAxEmC,CAAA,CAAA,SAwEnC,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAxCI,wBAAA,GAA2B,CAAA,CAAE,aACjC;cAGK,iCAA+B,CAAA,CAAA;;;;;;;;KAmChC,yBAAA,GAA4B,CAAA,CAAE,aAClC"}

package/api.d.ts

@@ -1,71 +0,0 @@
-import { EmptyToNever, Flatten, MakePartial } from "./util.js";
-import { $ZodBase64, $ZodBase64URL, $ZodCIDRv4, $ZodCIDRv6, $ZodCUID, $ZodCUID2, $ZodCustom, $ZodE164, $ZodEmail, $ZodEmoji, $ZodEnum, $ZodGUID, $ZodIPv4, $ZodIPv6, $ZodISODate, $ZodISODateTime, $ZodISODuration, $ZodISOTime, $ZodJWT, $ZodKSUID, $ZodNanoID, $ZodNonOptional, $ZodStringFormat, $ZodType, $ZodULID, $ZodURL, $ZodUUID, $ZodXID, ParsePayload } from "./schemas.js";
-import { $ZodCheck, $ZodCheckEndsWith, $ZodCheckGreaterThan, $ZodCheckIncludes, $ZodCheckLengthEquals, $ZodCheckLessThan, $ZodCheckLowerCase, $ZodCheckMaxLength, $ZodCheckMinLength, $ZodCheckMultipleOf, $ZodCheckNumberFormat, $ZodCheckRegex, $ZodCheckStartsWith, $ZodCheckUpperCase } from "./checks.js";
-import { $ZodErrorMap, $ZodIssue, $ZodIssueBase } from "./errors.js";
-
-//#region ../../node_modules/.bun/zod@4.1.12/node_modules/zod/v4/core/api.d.cts
-type Params<T extends $ZodType | $ZodCheck, IssueTypes extends $ZodIssueBase, OmitKeys extends keyof T["_zod"]["def"] = never> = Flatten<Partial<EmptyToNever<Omit<T["_zod"]["def"], OmitKeys> & ([IssueTypes] extends [never] ? {} : {
-  error?: string | $ZodErrorMap<IssueTypes> | undefined;
-  /** @deprecated This parameter is deprecated. Use `error` instead. */
-  message?: string | undefined;
-})>>>;
-type TypeParams<T extends $ZodType = $ZodType & {
-  _isst: never;
-}, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error"> = never> = Params<T, NonNullable<T["_zod"]["isst"]>, "type" | "checks" | "error" | AlsoOmit>;
-type CheckParams<T extends $ZodCheck = $ZodCheck,
-// & { _issc: never },
-AlsoOmit extends Exclude<keyof T["_zod"]["def"], "check" | "error"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "check" | "error" | AlsoOmit>;
-type CheckStringFormatParams<T extends $ZodStringFormat = $ZodStringFormat, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "coerce" | "checks" | "error" | "check" | "format"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit>;
-type CheckTypeParams<T extends $ZodType & $ZodCheck = $ZodType & $ZodCheck, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error" | "check"> = never> = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "checks" | "error" | "check" | AlsoOmit>;
-type $ZodCheckEmailParams = CheckStringFormatParams<$ZodEmail, "when">;
-type $ZodCheckGUIDParams = CheckStringFormatParams<$ZodGUID, "pattern" | "when">;
-type $ZodCheckUUIDParams = CheckStringFormatParams<$ZodUUID, "pattern" | "when">;
-type $ZodCheckURLParams = CheckStringFormatParams<$ZodURL, "when">;
-type $ZodCheckEmojiParams = CheckStringFormatParams<$ZodEmoji, "when">;
-type $ZodCheckNanoIDParams = CheckStringFormatParams<$ZodNanoID, "when">;
-type $ZodCheckCUIDParams = CheckStringFormatParams<$ZodCUID, "when">;
-type $ZodCheckCUID2Params = CheckStringFormatParams<$ZodCUID2, "when">;
-type $ZodCheckULIDParams = CheckStringFormatParams<$ZodULID, "when">;
-type $ZodCheckXIDParams = CheckStringFormatParams<$ZodXID, "when">;
-type $ZodCheckKSUIDParams = CheckStringFormatParams<$ZodKSUID, "when">;
-type $ZodCheckIPv4Params = CheckStringFormatParams<$ZodIPv4, "pattern" | "when" | "version">;
-type $ZodCheckIPv6Params = CheckStringFormatParams<$ZodIPv6, "pattern" | "when" | "version">;
-type $ZodCheckCIDRv4Params = CheckStringFormatParams<$ZodCIDRv4, "pattern" | "when">;
-type $ZodCheckCIDRv6Params = CheckStringFormatParams<$ZodCIDRv6, "pattern" | "when">;
-type $ZodCheckBase64Params = CheckStringFormatParams<$ZodBase64, "pattern" | "when">;
-type $ZodCheckBase64URLParams = CheckStringFormatParams<$ZodBase64URL, "pattern" | "when">;
-type $ZodCheckE164Params = CheckStringFormatParams<$ZodE164, "when">;
-type $ZodCheckJWTParams = CheckStringFormatParams<$ZodJWT, "pattern" | "when">;
-type $ZodCheckISODateTimeParams = CheckStringFormatParams<$ZodISODateTime, "pattern" | "when">;
-type $ZodCheckISODateParams = CheckStringFormatParams<$ZodISODate, "pattern" | "when">;
-type $ZodCheckISOTimeParams = CheckStringFormatParams<$ZodISOTime, "pattern" | "when">;
-type $ZodCheckISODurationParams = CheckStringFormatParams<$ZodISODuration, "when">;
-type $ZodCheckNumberFormatParams = CheckParams<$ZodCheckNumberFormat, "format" | "when">;
-type $ZodCheckLessThanParams = CheckParams<$ZodCheckLessThan, "inclusive" | "value" | "when">;
-type $ZodCheckGreaterThanParams = CheckParams<$ZodCheckGreaterThan, "inclusive" | "value" | "when">;
-type $ZodCheckMultipleOfParams = CheckParams<$ZodCheckMultipleOf, "value" | "when">;
-type $ZodCheckMaxLengthParams = CheckParams<$ZodCheckMaxLength, "maximum" | "when">;
-type $ZodCheckMinLengthParams = CheckParams<$ZodCheckMinLength, "minimum" | "when">;
-type $ZodCheckLengthEqualsParams = CheckParams<$ZodCheckLengthEquals, "length" | "when">;
-type $ZodCheckRegexParams = CheckParams<$ZodCheckRegex, "format" | "pattern" | "when">;
-type $ZodCheckLowerCaseParams = CheckParams<$ZodCheckLowerCase, "format" | "when">;
-type $ZodCheckUpperCaseParams = CheckParams<$ZodCheckUpperCase, "format" | "when">;
-type $ZodCheckIncludesParams = CheckParams<$ZodCheckIncludes, "includes" | "format" | "when" | "pattern">;
-type $ZodCheckStartsWithParams = CheckParams<$ZodCheckStartsWith, "prefix" | "format" | "when" | "pattern">;
-type $ZodCheckEndsWithParams = CheckParams<$ZodCheckEndsWith, "suffix" | "format" | "pattern" | "when">;
-type $ZodEnumParams = TypeParams<$ZodEnum, "entries">;
-type $ZodNonOptionalParams = TypeParams<$ZodNonOptional, "innerType">;
-type $ZodCustomParams = CheckTypeParams<$ZodCustom, "fn">;
-type $ZodSuperRefineIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
-type RawIssue<T extends $ZodIssueBase> = T extends any ? Flatten<MakePartial<T, "message" | "path"> & {
-  /** The schema or check that originated this issue. */
-  readonly inst?: $ZodType | $ZodCheck;
-  /** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */
-  readonly continue?: boolean | undefined;
-} & Record<string, unknown>> : never;
-interface $RefinementCtx<T = unknown> extends ParsePayload<T> {
-  addIssue(arg: string | $ZodSuperRefineIssue): void;
-}
-//#endregion
-export { $RefinementCtx, $ZodCheckBase64Params, $ZodCheckBase64URLParams, $ZodCheckCIDRv4Params, $ZodCheckCIDRv6Params, $ZodCheckCUID2Params, $ZodCheckCUIDParams, $ZodCheckE164Params, $ZodCheckEmailParams, $ZodCheckEmojiParams, $ZodCheckEndsWithParams, $ZodCheckGUIDParams, $ZodCheckGreaterThanParams, $ZodCheckIPv4Params, $ZodCheckIPv6Params, $ZodCheckISODateParams, $ZodCheckISODateTimeParams, $ZodCheckISODurationParams, $ZodCheckISOTimeParams, $ZodCheckIncludesParams, $ZodCheckJWTParams, $ZodCheckKSUIDParams, $ZodCheckLengthEqualsParams, $ZodCheckLessThanParams, $ZodCheckLowerCaseParams, $ZodCheckMaxLengthParams, $ZodCheckMinLengthParams, $ZodCheckMultipleOfParams, $ZodCheckNanoIDParams, $ZodCheckNumberFormatParams, $ZodCheckRegexParams, $ZodCheckStartsWithParams, $ZodCheckULIDParams, $ZodCheckURLParams, $ZodCheckUUIDParams, $ZodCheckUpperCaseParams, $ZodCheckXIDParams, $ZodCustomParams, $ZodEnumParams, $ZodNonOptionalParams };
-//# sourceMappingURL=api.d.ts.map

package/api.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api.d.ts","names":["checks","core","errors","schemas","util","Params","T","IssueTypes","OmitKeys","$ZodType","$ZodCheck","$ZodIssueBase","Omit","$ZodErrorMap","EmptyToNever","Partial","Flatten","TypeParams","AlsoOmit","Exclude","NonNullable","CheckParams","StringFormatParams","$ZodStringFormat","CheckStringFormatParams","CheckTypeParams","$ZodStringParams","$ZodString","_string","SchemaClass","_coercedString","$ZodStringFormatParams","$ZodCheckStringFormatParams","$ZodCheckStringFormat","$ZodEmailParams","$ZodEmail","$ZodCheckEmailParams","_email","$ZodGUIDParams","$ZodGUID","$ZodCheckGUIDParams","_guid","$ZodUUIDParams","$ZodUUID","$ZodCheckUUIDParams","_uuid","$ZodUUIDv4Params","$ZodCheckUUIDv4Params","_uuidv4","$ZodUUIDv6Params","$ZodCheckUUIDv6Params","_uuidv6","$ZodUUIDv7Params","$ZodCheckUUIDv7Params","_uuidv7","$ZodURLParams","$ZodURL","$ZodCheckURLParams","_url","$ZodEmojiParams","$ZodEmoji","$ZodCheckEmojiParams","_emoji","$ZodNanoIDParams","$ZodNanoID","$ZodCheckNanoIDParams","_nanoid","$ZodCUIDParams","$ZodCUID","$ZodCheckCUIDParams","_cuid","$ZodCUID2Params","$ZodCUID2","$ZodCheckCUID2Params","_cuid2","$ZodULIDParams","$ZodULID","$ZodCheckULIDParams","_ulid","$ZodXIDParams","$ZodXID","$ZodCheckXIDParams","_xid","$ZodKSUIDParams","$ZodKSUID","$ZodCheckKSUIDParams","_ksuid","$ZodIPv4Params","$ZodIPv4","$ZodCheckIPv4Params","_ipv4","$ZodIPv6Params","$ZodIPv6","$ZodCheckIPv6Params","_ipv6","$ZodCIDRv4Params","$ZodCIDRv4","$ZodCheckCIDRv4Params","_cidrv4","$ZodCIDRv6Params","$ZodCIDRv6","$ZodCheckCIDRv6Params","_cidrv6","$ZodBase64Params","$ZodBase64","$ZodCheckBase64Params","_base64","$ZodBase64URLParams","$ZodBase64URL","$ZodCheckBase64URLParams","_base64url","$ZodE164Params","$ZodE164","$ZodCheckE164Params","_e164","$ZodJWTParams","$ZodJWT","$ZodCheckJWTParams","_jwt","TimePrecision","$ZodISODateTimeParams","$ZodISODateTime","$ZodCheckISODateTimeParams","_isoDateTime","$ZodISODateParams","$ZodISODate","$ZodCheckISODateParams","_isoDate","$ZodISOTimeParams","$ZodISOTime","$ZodCheckISOTimeParams","_isoTime","$ZodISODurationParams","$ZodISODuration","$ZodCheckISODurationParams","_isoDuration","$ZodNumberParams","$ZodNumber","$ZodNumberFormatParams","$ZodNumberFormat","$ZodCheckNumberFormatParams","$ZodCheckNumberFormat","_number","_coercedNumber","_int","_float32","_float64","_int32","_uint32","$ZodBooleanParams","$ZodBoolean","_boolean","_coercedBoolean","$ZodBigIntParams","$ZodBigInt","$ZodBigIntFormatParams","$ZodBigIntFormat","$ZodCheckBigIntFormatParams","$ZodCheckBigIntFormat","_bigint","_coercedBigint","_int64","_uint64","$ZodSymbolParams","$ZodSymbol","_symbol","$ZodUndefinedParams","$ZodUndefined","_undefined","$ZodNullParams","$ZodNull","_null","$ZodAnyParams","$ZodAny","_any","$ZodUnknownParams","$ZodUnknown","_unknown","$ZodNeverParams","$ZodNever","_never","$ZodVoidParams","$ZodVoid","_void","$ZodDateParams","$ZodDate","_date","_coercedDate","$ZodNaNParams","$ZodNaN","_nan","$ZodCheckLessThanParams","$ZodCheckLessThan","_lt","Numeric","_lte","_max","$ZodCheckGreaterThanParams","$ZodCheckGreaterThan","_gt","_gte","_min","_positive","_negative","_nonpositive","_nonnegative","$ZodCheckMultipleOfParams","$ZodCheckMultipleOf","_multipleOf","$ZodCheckMaxSizeParams","$ZodCheckMaxSize","_maxSize","HasSize","$ZodCheckMinSizeParams","$ZodCheckMinSize","_minSize","$ZodCheckSizeEqualsParams","$ZodCheckSizeEquals","_size","$ZodCheckMaxLengthParams","$ZodCheckMaxLength","_maxLength","HasLength","$ZodCheckMinLengthParams","$ZodCheckMinLength","_minLength","$ZodCheckLengthEqualsParams","$ZodCheckLengthEquals","_length","$ZodCheckRegexParams","$ZodCheckRegex","_regex","RegExp","$ZodCheckLowerCaseParams","$ZodCheckLowerCase","_lowercase","$ZodCheckUpperCaseParams","$ZodCheckUpperCase","_uppercase","$ZodCheckIncludesParams","$ZodCheckIncludes","_includes","$ZodCheckStartsWithParams","$ZodCheckStartsWith","_startsWith","$ZodCheckEndsWithParams","$ZodCheckEndsWith","_endsWith","$ZodCheckPropertyParams","$ZodCheckProperty","_property","K","output","$ZodCheckMimeTypeParams","$ZodCheckMimeType","_mime","MimeTypes","_overwrite","$ZodCheckOverwrite","_normalize","_trim","_toLowerCase","_toUpperCase","$ZodArrayParams","$ZodArray","_array","$ZodObjectParams","$ZodObject","$ZodUnionParams","$ZodUnion","_union","$ZodTypeDiscriminableInternals","PropValues","$ZodTypeInternals","$ZodTypeDiscriminable","$ZodDiscriminatedUnionParams","$ZodDiscriminatedUnion","_discriminatedUnion","Types","Disc","$ZodIntersectionParams","$ZodIntersection","_intersection","U","$ZodTupleParams","$ZodTuple","_tuple","Rest","$ZodRecordParams","$ZodRecord","_record","Key","Value","$ZodRecordKey","$ZodMapParams","$ZodMap","_map","$ZodSetParams","$ZodSet","_set","$ZodEnumParams","$ZodEnum","_enum","ToEnum","EnumLike","_nativeEnum","$ZodLiteralParams","$ZodLiteral","_literal","Literal","Array","$ZodFileParams","$ZodFile","_file","$ZodTransformParams","$ZodTransform","_transform","I","O","ParsePayload","Awaited","$ZodOptionalParams","$ZodOptional","_optional","$ZodNullableParams","$ZodNullable","_nullable","$ZodDefaultParams","$ZodDefault","_default","NoUndefined","$ZodNonOptionalParams","$ZodNonOptional","_nonoptional","$ZodSuccessParams","$ZodSuccess","_success","$ZodCatchParams","$ZodCatch","_catch","$ZodCatchCtx","$ZodPipeParams","$ZodPipe","_pipe","A","B","$ZodReadonlyParams","$ZodReadonly","_readonly","$ZodTemplateLiteralParams","$ZodTemplateLiteral","_templateLiteral","Parts","$ZodTemplateLiteralPart","$PartsToTemplateLiteral","$ZodLazyParams","$ZodLazy","_lazy","$ZodPromiseParams","$ZodPromise","_promise","$ZodCustomParams","$ZodCustom","_custom","_refine","$ZodSuperRefineIssue","$ZodIssue","RawIssue","MakePartial","Record","$RefinementCtx","_superRefine","Promise","_check","CheckFn","$ZodStringBoolParams","_stringbool","$ZodCodec","_stringFormat","Format","$ZodCustomStringFormat","MaybeAsync"],"sources":["../../../node_modules/.bun/zod@4.1.12/node_modules/zod/v4/core/api.d.cts"],"sourcesContent":["import * as checks from \"./checks.cjs\";\nimport type * as core from \"./core.cjs\";\nimport type * as errors from \"./errors.cjs\";\nimport * as schemas from \"./schemas.cjs\";\nimport * as util from \"./util.cjs\";\nexport type Params<T extends schemas.$ZodType | checks.$ZodCheck, IssueTypes extends errors.$ZodIssueBase, OmitKeys extends keyof T[\"_zod\"][\"def\"] = never> = util.Flatten<Partial<util.EmptyToNever<Omit<T[\"_zod\"][\"def\"], OmitKeys> & ([IssueTypes] extends [never] ? {} : {\n    error?: string | errors.$ZodErrorMap<IssueTypes> | undefined;\n    /** @deprecated This parameter is deprecated. Use `error` instead. */\n    message?: string | undefined;\n})>>>;\nexport type TypeParams<T extends schemas.$ZodType = schemas.$ZodType & {\n    _isst: never;\n}, AlsoOmit extends Exclude<keyof T[\"_zod\"][\"def\"], \"type\" | \"checks\" | \"error\"> = never> = Params<T, NonNullable<T[\"_zod\"][\"isst\"]>, \"type\" | \"checks\" | \"error\" | AlsoOmit>;\nexport type CheckParams<T extends checks.$ZodCheck = checks.$ZodCheck, // & { _issc: never },\nAlsoOmit extends Exclude<keyof T[\"_zod\"][\"def\"], \"check\" | \"error\"> = never> = Params<T, NonNullable<T[\"_zod\"][\"issc\"]>, \"check\" | \"error\" | AlsoOmit>;\nexport type StringFormatParams<T extends schemas.$ZodStringFormat = schemas.$ZodStringFormat, AlsoOmit extends Exclude<keyof T[\"_zod\"][\"def\"], \"type\" | \"coerce\" | \"checks\" | \"error\" | \"check\" | \"format\"> = never> = Params<T, NonNullable<T[\"_zod\"][\"isst\"] | T[\"_zod\"][\"issc\"]>, \"type\" | \"coerce\" | \"checks\" | \"error\" | \"check\" | \"format\" | AlsoOmit>;\nexport type CheckStringFormatParams<T extends schemas.$ZodStringFormat = schemas.$ZodStringFormat, AlsoOmit extends Exclude<keyof T[\"_zod\"][\"def\"], \"type\" | \"coerce\" | \"checks\" | \"error\" | \"check\" | \"format\"> = never> = Params<T, NonNullable<T[\"_zod\"][\"issc\"]>, \"type\" | \"coerce\" | \"checks\" | \"error\" | \"check\" | \"format\" | AlsoOmit>;\nexport type CheckTypeParams<T extends schemas.$ZodType & checks.$ZodCheck = schemas.$ZodType & checks.$ZodCheck, AlsoOmit extends Exclude<keyof T[\"_zod\"][\"def\"], \"type\" | \"checks\" | \"error\" | \"check\"> = never> = Params<T, NonNullable<T[\"_zod\"][\"isst\"] | T[\"_zod\"][\"issc\"]>, \"type\" | \"checks\" | \"error\" | \"check\" | AlsoOmit>;\nexport type $ZodStringParams = TypeParams<schemas.$ZodString<string>, \"coerce\">;\nexport declare function _string<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;\nexport declare function _coercedString<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;\nexport type $ZodStringFormatParams = CheckTypeParams<schemas.$ZodStringFormat, \"format\" | \"coerce\" | \"when\" | \"pattern\">;\nexport type $ZodCheckStringFormatParams = CheckParams<checks.$ZodCheckStringFormat, \"format\">;\nexport type $ZodEmailParams = StringFormatParams<schemas.$ZodEmail, \"when\">;\nexport type $ZodCheckEmailParams = CheckStringFormatParams<schemas.$ZodEmail, \"when\">;\nexport declare function _email<T extends schemas.$ZodEmail>(Class: util.SchemaClass<T>, params?: string | $ZodEmailParams | $ZodCheckEmailParams): T;\nexport type $ZodGUIDParams = StringFormatParams<schemas.$ZodGUID, \"pattern\" | \"when\">;\nexport type $ZodCheckGUIDParams = CheckStringFormatParams<schemas.$ZodGUID, \"pattern\" | \"when\">;\nexport declare function _guid<T extends schemas.$ZodGUID>(Class: util.SchemaClass<T>, params?: string | $ZodGUIDParams | $ZodCheckGUIDParams): T;\nexport type $ZodUUIDParams = StringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport type $ZodCheckUUIDParams = CheckStringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport declare function _uuid<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDParams | $ZodCheckUUIDParams): T;\nexport type $ZodUUIDv4Params = StringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport type $ZodCheckUUIDv4Params = CheckStringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport declare function _uuidv4<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv4Params | $ZodCheckUUIDv4Params): T;\nexport type $ZodUUIDv6Params = StringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport type $ZodCheckUUIDv6Params = CheckStringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport declare function _uuidv6<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv6Params | $ZodCheckUUIDv6Params): T;\nexport type $ZodUUIDv7Params = StringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport type $ZodCheckUUIDv7Params = CheckStringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport declare function _uuidv7<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv7Params | $ZodCheckUUIDv7Params): T;\nexport type $ZodURLParams = StringFormatParams<schemas.$ZodURL, \"when\">;\nexport type $ZodCheckURLParams = CheckStringFormatParams<schemas.$ZodURL, \"when\">;\nexport declare function _url<T extends schemas.$ZodURL>(Class: util.SchemaClass<T>, params?: string | $ZodURLParams | $ZodCheckURLParams): T;\nexport type $ZodEmojiParams = StringFormatParams<schemas.$ZodEmoji, \"when\">;\nexport type $ZodCheckEmojiParams = CheckStringFormatParams<schemas.$ZodEmoji, \"when\">;\nexport declare function _emoji<T extends schemas.$ZodEmoji>(Class: util.SchemaClass<T>, params?: string | $ZodEmojiParams | $ZodCheckEmojiParams): T;\nexport type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID, \"when\">;\nexport type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID, \"when\">;\nexport declare function _nanoid<T extends schemas.$ZodNanoID>(Class: util.SchemaClass<T>, params?: string | $ZodNanoIDParams | $ZodCheckNanoIDParams): T;\nexport type $ZodCUIDParams = StringFormatParams<schemas.$ZodCUID, \"when\">;\nexport type $ZodCheckCUIDParams = CheckStringFormatParams<schemas.$ZodCUID, \"when\">;\nexport declare function _cuid<T extends schemas.$ZodCUID>(Class: util.SchemaClass<T>, params?: string | $ZodCUIDParams | $ZodCheckCUIDParams): T;\nexport type $ZodCUID2Params = StringFormatParams<schemas.$ZodCUID2, \"when\">;\nexport type $ZodCheckCUID2Params = CheckStringFormatParams<schemas.$ZodCUID2, \"when\">;\nexport declare function _cuid2<T extends schemas.$ZodCUID2>(Class: util.SchemaClass<T>, params?: string | $ZodCUID2Params | $ZodCheckCUID2Params): T;\nexport type $ZodULIDParams = StringFormatParams<schemas.$ZodULID, \"when\">;\nexport type $ZodCheckULIDParams = CheckStringFormatParams<schemas.$ZodULID, \"when\">;\nexport declare function _ulid<T extends schemas.$ZodULID>(Class: util.SchemaClass<T>, params?: string | $ZodULIDParams | $ZodCheckULIDParams): T;\nexport type $ZodXIDParams = StringFormatParams<schemas.$ZodXID, \"when\">;\nexport type $ZodCheckXIDParams = CheckStringFormatParams<schemas.$ZodXID, \"when\">;\nexport declare function _xid<T extends schemas.$ZodXID>(Class: util.SchemaClass<T>, params?: string | $ZodXIDParams | $ZodCheckXIDParams): T;\nexport type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID, \"when\">;\nexport type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID, \"when\">;\nexport declare function _ksuid<T extends schemas.$ZodKSUID>(Class: util.SchemaClass<T>, params?: string | $ZodKSUIDParams | $ZodCheckKSUIDParams): T;\nexport type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, \"pattern\" | \"when\" | \"version\">;\nexport type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, \"pattern\" | \"when\" | \"version\">;\nexport declare function _ipv4<T extends schemas.$ZodIPv4>(Class: util.SchemaClass<T>, params?: string | $ZodIPv4Params | $ZodCheckIPv4Params): T;\nexport type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, \"pattern\" | \"when\" | \"version\">;\nexport type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, \"pattern\" | \"when\" | \"version\">;\nexport declare function _ipv6<T extends schemas.$ZodIPv6>(Class: util.SchemaClass<T>, params?: string | $ZodIPv6Params | $ZodCheckIPv6Params): T;\nexport type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, \"pattern\" | \"when\">;\nexport type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, \"pattern\" | \"when\">;\nexport declare function _cidrv4<T extends schemas.$ZodCIDRv4>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv4Params | $ZodCheckCIDRv4Params): T;\nexport type $ZodCIDRv6Params = StringFormatParams<schemas.$ZodCIDRv6, \"pattern\" | \"when\">;\nexport type $ZodCheckCIDRv6Params = CheckStringFormatParams<schemas.$ZodCIDRv6, \"pattern\" | \"when\">;\nexport declare function _cidrv6<T extends schemas.$ZodCIDRv6>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv6Params | $ZodCheckCIDRv6Params): T;\nexport type $ZodBase64Params = StringFormatParams<schemas.$ZodBase64, \"pattern\" | \"when\">;\nexport type $ZodCheckBase64Params = CheckStringFormatParams<schemas.$ZodBase64, \"pattern\" | \"when\">;\nexport declare function _base64<T extends schemas.$ZodBase64>(Class: util.SchemaClass<T>, params?: string | $ZodBase64Params | $ZodCheckBase64Params): T;\nexport type $ZodBase64URLParams = StringFormatParams<schemas.$ZodBase64URL, \"pattern\" | \"when\">;\nexport type $ZodCheckBase64URLParams = CheckStringFormatParams<schemas.$ZodBase64URL, \"pattern\" | \"when\">;\nexport declare function _base64url<T extends schemas.$ZodBase64URL>(Class: util.SchemaClass<T>, params?: string | $ZodBase64URLParams | $ZodCheckBase64URLParams): T;\nexport type $ZodE164Params = StringFormatParams<schemas.$ZodE164, \"when\">;\nexport type $ZodCheckE164Params = CheckStringFormatParams<schemas.$ZodE164, \"when\">;\nexport declare function _e164<T extends schemas.$ZodE164>(Class: util.SchemaClass<T>, params?: string | $ZodE164Params | $ZodCheckE164Params): T;\nexport type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, \"pattern\" | \"when\">;\nexport type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, \"pattern\" | \"when\">;\nexport declare function _jwt<T extends schemas.$ZodJWT>(Class: util.SchemaClass<T>, params?: string | $ZodJWTParams | $ZodCheckJWTParams): T;\nexport declare const TimePrecision: {\n    readonly Any: null;\n    readonly Minute: -1;\n    readonly Second: 0;\n    readonly Millisecond: 3;\n    readonly Microsecond: 6;\n};\nexport type $ZodISODateTimeParams = StringFormatParams<schemas.$ZodISODateTime, \"pattern\" | \"when\">;\nexport type $ZodCheckISODateTimeParams = CheckStringFormatParams<schemas.$ZodISODateTime, \"pattern\" | \"when\">;\nexport declare function _isoDateTime<T extends schemas.$ZodISODateTime>(Class: util.SchemaClass<T>, params?: string | $ZodISODateTimeParams | $ZodCheckISODateTimeParams): T;\nexport type $ZodISODateParams = StringFormatParams<schemas.$ZodISODate, \"pattern\" | \"when\">;\nexport type $ZodCheckISODateParams = CheckStringFormatParams<schemas.$ZodISODate, \"pattern\" | \"when\">;\nexport declare function _isoDate<T extends schemas.$ZodISODate>(Class: util.SchemaClass<T>, params?: string | $ZodISODateParams | $ZodCheckISODateParams): T;\nexport type $ZodISOTimeParams = StringFormatParams<schemas.$ZodISOTime, \"pattern\" | \"when\">;\nexport type $ZodCheckISOTimeParams = CheckStringFormatParams<schemas.$ZodISOTime, \"pattern\" | \"when\">;\nexport declare function _isoTime<T extends schemas.$ZodISOTime>(Class: util.SchemaClass<T>, params?: string | $ZodISOTimeParams | $ZodCheckISOTimeParams): T;\nexport type $ZodISODurationParams = StringFormatParams<schemas.$ZodISODuration, \"when\">;\nexport type $ZodCheckISODurationParams = CheckStringFormatParams<schemas.$ZodISODuration, \"when\">;\nexport declare function _isoDuration<T extends schemas.$ZodISODuration>(Class: util.SchemaClass<T>, params?: string | $ZodISODurationParams | $ZodCheckISODurationParams): T;\nexport type $ZodNumberParams = TypeParams<schemas.$ZodNumber<number>, \"coerce\">;\nexport type $ZodNumberFormatParams = CheckTypeParams<schemas.$ZodNumberFormat, \"format\" | \"coerce\">;\nexport type $ZodCheckNumberFormatParams = CheckParams<checks.$ZodCheckNumberFormat, \"format\" | \"when\">;\nexport declare function _number<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;\nexport declare function _coercedNumber<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;\nexport declare function _int<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport declare function _float32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport declare function _float64<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport declare function _int32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport declare function _uint32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport type $ZodBooleanParams = TypeParams<schemas.$ZodBoolean<boolean>, \"coerce\">;\nexport declare function _boolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;\nexport declare function _coercedBoolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;\nexport type $ZodBigIntParams = TypeParams<schemas.$ZodBigInt<bigint>>;\nexport type $ZodBigIntFormatParams = CheckTypeParams<schemas.$ZodBigIntFormat, \"format\" | \"coerce\">;\nexport type $ZodCheckBigIntFormatParams = CheckParams<checks.$ZodCheckBigIntFormat, \"format\" | \"when\">;\nexport declare function _bigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;\nexport declare function _coercedBigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;\nexport declare function _int64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;\nexport declare function _uint64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;\nexport type $ZodSymbolParams = TypeParams<schemas.$ZodSymbol>;\nexport declare function _symbol<T extends schemas.$ZodSymbol>(Class: util.SchemaClass<T>, params?: string | $ZodSymbolParams): T;\nexport type $ZodUndefinedParams = TypeParams<schemas.$ZodUndefined>;\nexport declare function _undefined<T extends schemas.$ZodUndefined>(Class: util.SchemaClass<T>, params?: string | $ZodUndefinedParams): T;\nexport type $ZodNullParams = TypeParams<schemas.$ZodNull>;\nexport declare function _null<T extends schemas.$ZodNull>(Class: util.SchemaClass<T>, params?: string | $ZodNullParams): T;\nexport type $ZodAnyParams = TypeParams<schemas.$ZodAny>;\nexport declare function _any<T extends schemas.$ZodAny>(Class: util.SchemaClass<T>): T;\nexport type $ZodUnknownParams = TypeParams<schemas.$ZodUnknown>;\nexport declare function _unknown<T extends schemas.$ZodUnknown>(Class: util.SchemaClass<T>): T;\nexport type $ZodNeverParams = TypeParams<schemas.$ZodNever>;\nexport declare function _never<T extends schemas.$ZodNever>(Class: util.SchemaClass<T>, params?: string | $ZodNeverParams): T;\nexport type $ZodVoidParams = TypeParams<schemas.$ZodVoid>;\nexport declare function _void<T extends schemas.$ZodVoid>(Class: util.SchemaClass<T>, params?: string | $ZodVoidParams): T;\nexport type $ZodDateParams = TypeParams<schemas.$ZodDate, \"coerce\">;\nexport declare function _date<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;\nexport declare function _coercedDate<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;\nexport type $ZodNaNParams = TypeParams<schemas.$ZodNaN>;\nexport declare function _nan<T extends schemas.$ZodNaN>(Class: util.SchemaClass<T>, params?: string | $ZodNaNParams): T;\nexport type $ZodCheckLessThanParams = CheckParams<checks.$ZodCheckLessThan, \"inclusive\" | \"value\" | \"when\">;\nexport declare function _lt(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;\nexport declare function _lte(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;\nexport { \n/** @deprecated Use `z.lte()` instead. */\n_lte as _max, };\nexport type $ZodCheckGreaterThanParams = CheckParams<checks.$ZodCheckGreaterThan, \"inclusive\" | \"value\" | \"when\">;\nexport declare function _gt(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;\nexport declare function _gte(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;\nexport { \n/** @deprecated Use `z.gte()` instead. */\n_gte as _min, };\nexport declare function _positive(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;\nexport declare function _negative(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;\nexport declare function _nonpositive(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;\nexport declare function _nonnegative(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;\nexport type $ZodCheckMultipleOfParams = CheckParams<checks.$ZodCheckMultipleOf, \"value\" | \"when\">;\nexport declare function _multipleOf(value: number | bigint, params?: string | $ZodCheckMultipleOfParams): checks.$ZodCheckMultipleOf;\nexport type $ZodCheckMaxSizeParams = CheckParams<checks.$ZodCheckMaxSize, \"maximum\" | \"when\">;\nexport declare function _maxSize(maximum: number, params?: string | $ZodCheckMaxSizeParams): checks.$ZodCheckMaxSize<util.HasSize>;\nexport type $ZodCheckMinSizeParams = CheckParams<checks.$ZodCheckMinSize, \"minimum\" | \"when\">;\nexport declare function _minSize(minimum: number, params?: string | $ZodCheckMinSizeParams): checks.$ZodCheckMinSize<util.HasSize>;\nexport type $ZodCheckSizeEqualsParams = CheckParams<checks.$ZodCheckSizeEquals, \"size\" | \"when\">;\nexport declare function _size(size: number, params?: string | $ZodCheckSizeEqualsParams): checks.$ZodCheckSizeEquals<util.HasSize>;\nexport type $ZodCheckMaxLengthParams = CheckParams<checks.$ZodCheckMaxLength, \"maximum\" | \"when\">;\nexport declare function _maxLength(maximum: number, params?: string | $ZodCheckMaxLengthParams): checks.$ZodCheckMaxLength<util.HasLength>;\nexport type $ZodCheckMinLengthParams = CheckParams<checks.$ZodCheckMinLength, \"minimum\" | \"when\">;\nexport declare function _minLength(minimum: number, params?: string | $ZodCheckMinLengthParams): checks.$ZodCheckMinLength<util.HasLength>;\nexport type $ZodCheckLengthEqualsParams = CheckParams<checks.$ZodCheckLengthEquals, \"length\" | \"when\">;\nexport declare function _length(length: number, params?: string | $ZodCheckLengthEqualsParams): checks.$ZodCheckLengthEquals<util.HasLength>;\nexport type $ZodCheckRegexParams = CheckParams<checks.$ZodCheckRegex, \"format\" | \"pattern\" | \"when\">;\nexport declare function _regex(pattern: RegExp, params?: string | $ZodCheckRegexParams): checks.$ZodCheckRegex;\nexport type $ZodCheckLowerCaseParams = CheckParams<checks.$ZodCheckLowerCase, \"format\" | \"when\">;\nexport declare function _lowercase(params?: string | $ZodCheckLowerCaseParams): checks.$ZodCheckLowerCase;\nexport type $ZodCheckUpperCaseParams = CheckParams<checks.$ZodCheckUpperCase, \"format\" | \"when\">;\nexport declare function _uppercase(params?: string | $ZodCheckUpperCaseParams): checks.$ZodCheckUpperCase;\nexport type $ZodCheckIncludesParams = CheckParams<checks.$ZodCheckIncludes, \"includes\" | \"format\" | \"when\" | \"pattern\">;\nexport declare function _includes(includes: string, params?: string | $ZodCheckIncludesParams): checks.$ZodCheckIncludes;\nexport type $ZodCheckStartsWithParams = CheckParams<checks.$ZodCheckStartsWith, \"prefix\" | \"format\" | \"when\" | \"pattern\">;\nexport declare function _startsWith(prefix: string, params?: string | $ZodCheckStartsWithParams): checks.$ZodCheckStartsWith;\nexport type $ZodCheckEndsWithParams = CheckParams<checks.$ZodCheckEndsWith, \"suffix\" | \"format\" | \"pattern\" | \"when\">;\nexport declare function _endsWith(suffix: string, params?: string | $ZodCheckEndsWithParams): checks.$ZodCheckEndsWith;\nexport type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, \"property\" | \"schema\" | \"when\">;\nexport declare function _property<K extends string, T extends schemas.$ZodType>(property: K, schema: T, params?: string | $ZodCheckPropertyParams): checks.$ZodCheckProperty<{\n    [k in K]: core.output<T>;\n}>;\nexport type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, \"mime\" | \"when\">;\nexport declare function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTypeParams): checks.$ZodCheckMimeType;\nexport declare function _overwrite<T>(tx: (input: T) => T): checks.$ZodCheckOverwrite<T>;\nexport declare function _normalize(form?: \"NFC\" | \"NFD\" | \"NFKC\" | \"NFKD\" | (string & {})): checks.$ZodCheckOverwrite<string>;\nexport declare function _trim(): checks.$ZodCheckOverwrite<string>;\nexport declare function _toLowerCase(): checks.$ZodCheckOverwrite<string>;\nexport declare function _toUpperCase(): checks.$ZodCheckOverwrite<string>;\nexport type $ZodArrayParams = TypeParams<schemas.$ZodArray, \"element\">;\nexport declare function _array<T extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodArray>, element: T, params?: string | $ZodArrayParams): schemas.$ZodArray<T>;\nexport type $ZodObjectParams = TypeParams<schemas.$ZodObject, \"shape\" | \"catchall\">;\nexport type $ZodUnionParams = TypeParams<schemas.$ZodUnion, \"options\">;\nexport declare function _union<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodUnion>, options: T, params?: string | $ZodUnionParams): schemas.$ZodUnion<T>;\nexport interface $ZodTypeDiscriminableInternals extends schemas.$ZodTypeInternals {\n    propValues: util.PropValues;\n}\nexport interface $ZodTypeDiscriminable extends schemas.$ZodType {\n    _zod: $ZodTypeDiscriminableInternals;\n}\nexport type $ZodDiscriminatedUnionParams = TypeParams<schemas.$ZodDiscriminatedUnion, \"options\" | \"discriminator\">;\nexport declare function _discriminatedUnion<Types extends [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]], Disc extends string>(Class: util.SchemaClass<schemas.$ZodDiscriminatedUnion>, discriminator: Disc, options: Types, params?: string | $ZodDiscriminatedUnionParams): schemas.$ZodDiscriminatedUnion<Types, Disc>;\nexport type $ZodIntersectionParams = TypeParams<schemas.$ZodIntersection, \"left\" | \"right\">;\nexport declare function _intersection<T extends schemas.$ZodObject, U extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodIntersection>, left: T, right: U): schemas.$ZodIntersection<T, U>;\nexport type $ZodTupleParams = TypeParams<schemas.$ZodTuple, \"items\" | \"rest\">;\nexport declare function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType[]]>(Class: util.SchemaClass<schemas.$ZodTuple>, items: T, params?: string | $ZodTupleParams): schemas.$ZodTuple<T, null>;\nexport declare function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType[]], Rest extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodTuple>, items: T, rest: Rest, params?: string | $ZodTupleParams): schemas.$ZodTuple<T, Rest>;\nexport type $ZodRecordParams = TypeParams<schemas.$ZodRecord, \"keyType\" | \"valueType\">;\nexport declare function _record<Key extends schemas.$ZodRecordKey, Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodRecord>, keyType: Key, valueType: Value, params?: string | $ZodRecordParams): schemas.$ZodRecord<Key, Value>;\nexport type $ZodMapParams = TypeParams<schemas.$ZodMap, \"keyType\" | \"valueType\">;\nexport declare function _map<Key extends schemas.$ZodObject, Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodMap>, keyType: Key, valueType: Value, params?: string | $ZodMapParams): schemas.$ZodMap<Key, Value>;\nexport type $ZodSetParams = TypeParams<schemas.$ZodSet, \"valueType\">;\nexport declare function _set<Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodSet>, valueType: Value, params?: string | $ZodSetParams): schemas.$ZodSet<Value>;\nexport type $ZodEnumParams = TypeParams<schemas.$ZodEnum, \"entries\">;\nexport declare function _enum<const T extends string[]>(Class: util.SchemaClass<schemas.$ZodEnum>, values: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<util.ToEnum<T[number]>>;\nexport declare function _enum<T extends util.EnumLike>(Class: util.SchemaClass<schemas.$ZodEnum>, entries: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<T>;\n/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.\n *\n * ```ts\n * enum Colors { red, green, blue }\n * z.enum(Colors);\n * ```\n */\nexport declare function _nativeEnum<T extends util.EnumLike>(Class: util.SchemaClass<schemas.$ZodEnum>, entries: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<T>;\nexport type $ZodLiteralParams = TypeParams<schemas.$ZodLiteral, \"values\">;\nexport declare function _literal<const T extends Array<util.Literal>>(Class: util.SchemaClass<schemas.$ZodLiteral>, value: T, params?: string | $ZodLiteralParams): schemas.$ZodLiteral<T[number]>;\nexport declare function _literal<const T extends util.Literal>(Class: util.SchemaClass<schemas.$ZodLiteral>, value: T, params?: string | $ZodLiteralParams): schemas.$ZodLiteral<T>;\nexport type $ZodFileParams = TypeParams<schemas.$ZodFile>;\nexport declare function _file(Class: util.SchemaClass<schemas.$ZodFile>, params?: string | $ZodFileParams): schemas.$ZodFile;\nexport type $ZodTransformParams = TypeParams<schemas.$ZodTransform, \"transform\">;\nexport declare function _transform<I = unknown, O = I>(Class: util.SchemaClass<schemas.$ZodTransform>, fn: (input: I, ctx?: schemas.ParsePayload) => O): schemas.$ZodTransform<Awaited<O>, I>;\nexport type $ZodOptionalParams = TypeParams<schemas.$ZodOptional, \"innerType\">;\nexport declare function _optional<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodOptional>, innerType: T): schemas.$ZodOptional<T>;\nexport type $ZodNullableParams = TypeParams<schemas.$ZodNullable, \"innerType\">;\nexport declare function _nullable<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodNullable>, innerType: T): schemas.$ZodNullable<T>;\nexport type $ZodDefaultParams = TypeParams<schemas.$ZodDefault, \"innerType\" | \"defaultValue\">;\nexport declare function _default<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodDefault>, innerType: T, defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)): schemas.$ZodDefault<T>;\nexport type $ZodNonOptionalParams = TypeParams<schemas.$ZodNonOptional, \"innerType\">;\nexport declare function _nonoptional<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodNonOptional>, innerType: T, params?: string | $ZodNonOptionalParams): schemas.$ZodNonOptional<T>;\nexport type $ZodSuccessParams = TypeParams<schemas.$ZodSuccess, \"innerType\">;\nexport declare function _success<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodSuccess>, innerType: T): schemas.$ZodSuccess<T>;\nexport type $ZodCatchParams = TypeParams<schemas.$ZodCatch, \"innerType\" | \"catchValue\">;\nexport declare function _catch<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodCatch>, innerType: T, catchValue: core.output<T> | ((ctx: schemas.$ZodCatchCtx) => core.output<T>)): schemas.$ZodCatch<T>;\nexport type $ZodPipeParams = TypeParams<schemas.$ZodPipe, \"in\" | \"out\">;\nexport declare function _pipe<const A extends schemas.$ZodType, B extends schemas.$ZodType<unknown, core.output<A>> = schemas.$ZodType<unknown, core.output<A>>>(Class: util.SchemaClass<schemas.$ZodPipe>, in_: A, out: B | schemas.$ZodType<unknown, core.output<A>>): schemas.$ZodPipe<A, B>;\nexport type $ZodReadonlyParams = TypeParams<schemas.$ZodReadonly, \"innerType\">;\nexport declare function _readonly<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodReadonly>, innerType: T): schemas.$ZodReadonly<T>;\nexport type $ZodTemplateLiteralParams = TypeParams<schemas.$ZodTemplateLiteral, \"parts\">;\nexport declare function _templateLiteral<const Parts extends schemas.$ZodTemplateLiteralPart[]>(Class: util.SchemaClass<schemas.$ZodTemplateLiteral>, parts: Parts, params?: string | $ZodTemplateLiteralParams): schemas.$ZodTemplateLiteral<schemas.$PartsToTemplateLiteral<Parts>>;\nexport type $ZodLazyParams = TypeParams<schemas.$ZodLazy, \"getter\">;\nexport declare function _lazy<T extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodLazy>, getter: () => T): schemas.$ZodLazy<T>;\nexport type $ZodPromiseParams = TypeParams<schemas.$ZodPromise, \"innerType\">;\nexport declare function _promise<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodPromise>, innerType: T): schemas.$ZodPromise<T>;\nexport type $ZodCustomParams = CheckTypeParams<schemas.$ZodCustom, \"fn\">;\nexport declare function _custom<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;\nexport declare function _refine<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;\nexport type $ZodSuperRefineIssue<T extends errors.$ZodIssueBase = errors.$ZodIssue> = T extends any ? RawIssue<T> : never;\ntype RawIssue<T extends errors.$ZodIssueBase> = T extends any ? util.Flatten<util.MakePartial<T, \"message\" | \"path\"> & {\n    /** The schema or check that originated this issue. */\n    readonly inst?: schemas.$ZodType | checks.$ZodCheck;\n    /** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */\n    readonly continue?: boolean | undefined;\n} & Record<string, unknown>> : never;\nexport interface $RefinementCtx<T = unknown> extends schemas.ParsePayload<T> {\n    addIssue(arg: string | $ZodSuperRefineIssue): void;\n}\nexport declare function _superRefine<T>(fn: (arg: T, payload: $RefinementCtx<T>) => void | Promise<void>): checks.$ZodCheck<T>;\nexport declare function _check<O = unknown>(fn: schemas.CheckFn<O>, params?: string | $ZodCustomParams): checks.$ZodCheck<O>;\nexport interface $ZodStringBoolParams extends TypeParams {\n    truthy?: string[];\n    falsy?: string[];\n    /**\n     * Options: `\"sensitive\"`, `\"insensitive\"`\n     *\n     * @default `\"insensitive\"`\n     */\n    case?: \"sensitive\" | \"insensitive\" | undefined;\n}\nexport declare function _stringbool(Classes: {\n    Codec?: typeof schemas.$ZodCodec;\n    Boolean?: typeof schemas.$ZodBoolean;\n    String?: typeof schemas.$ZodString;\n}, _params?: string | $ZodStringBoolParams): schemas.$ZodCodec<schemas.$ZodString, schemas.$ZodBoolean>;\nexport declare function _stringFormat<Format extends string>(Class: typeof schemas.$ZodCustomStringFormat, format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | $ZodStringFormatParams): schemas.$ZodCustomStringFormat<Format>;\n"],"x_google_ignoreList":[0],"mappings":"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"}