fuma 2.0.50 → 2.1.1

package/dist/utils/eventEmitter.js

@@ -4,12 +4,13 @@ export function createEventEmitter() {
         on(eventKey, callback) {
             if (!events[eventKey])
                 events[eventKey] = [];
-            events[eventKey].push(callback);
+            events[eventKey]?.push(callback);
             return function unsubscribe() {
                 if (!events[eventKey])
                     events[eventKey] = [];
-                const index = events[eventKey].indexOf(callback);
-                events[eventKey].splice(index, 1);
+                const index = events[eventKey]?.indexOf(callback);
+                if (index !== undefined && index > -1)
+                    events[eventKey]?.splice(index, 1);
             };
         },
         once(eventKey, callback) {
@@ -17,22 +18,25 @@ export function createEventEmitter() {
                 events[eventKey] = [];
             const _callback = (arg) => {
                 callback(arg);
-                const index = events[eventKey].indexOf(callback);
-                events[eventKey].splice(index, 1);
+                const index = events[eventKey]?.indexOf(callback);
+                if (index !== undefined && index > -1)
+                    events[eventKey]?.splice(index, 1);
             };
-            events[eventKey].push(_callback);
+            events[eventKey]?.push(_callback);
             return function unsubscribe() {
                 if (!events[eventKey])
                     events[eventKey] = [];
-                const index = events[eventKey].indexOf(callback);
-                events[eventKey].splice(index, 1);
+                const index = events[eventKey]?.indexOf(callback);
+                if (index !== undefined && index > -1)
+                    events[eventKey]?.splice(index, 1);
             };
         },
         off(eventKey, callback) {
             if (!events[eventKey])
                 events[eventKey] = [];
-            const index = events[eventKey].indexOf(callback);
-            events[eventKey].splice(index, 1);
+            const index = events[eventKey]?.indexOf(callback);
+            if (index !== undefined && index > -1)
+                events[eventKey]?.splice(index, 1);
         },
         clean(eventKey) {
             events[eventKey] = [];
@@ -40,7 +44,10 @@ export function createEventEmitter() {
         emit(...args) {
             if (!events[args[0]])
                 events[args[0]] = [];
-            events[args[0]].forEach((callback) => callback(args[1]));
+            const param = args[1];
+            events[args[0]]?.forEach((callback) => {
+                callback(param);
+            });
         }
     };
 }

package/dist/utils/index.d.ts

@@ -1,10 +1,8 @@
-export * from './component.js';
+export * from './constant.js';
+export * from './csv.js';
+export * from './eventEmitter.js';
 export * from './jsonParse.js';
+export * from './nestedPaths.js';
 export * from './normalizePath.js';
 export * from './options.js';
-export * from './avatar.js';
 export * from './tippy.js';
-export * from './nestedPaths.js';
-export * from './constant.js';
-export * from './csv.js';
-export * from './eventEmitter.js';

package/dist/utils/index.js

@@ -1,10 +1,8 @@
-export * from './component.js';
+export * from './constant.js';
+export * from './csv.js';
+export * from './eventEmitter.js';
 export * from './jsonParse.js';
+export * from './nestedPaths.js';
 export * from './normalizePath.js';
 export * from './options.js';
-export * from './avatar.js';
 export * from './tippy.js';
-export * from './nestedPaths.js';
-export * from './constant.js';
-export * from './csv.js';
-export * from './eventEmitter.js';

package/dist/utils/normalizePath.js

@@ -6,6 +6,6 @@ export function normalizePath(str) {
         .normalize('NFD')
         .replace(/[\u0300-\u036f]/g, '')
         .replaceAll(' ', '-')
-        .replace(/[\.\:\/\?\#\[\]\@\!\$\&\'\(\)\*\+\,\;\=]/g, '')
+        .replace(/[.:/?#[\]@!$&'()*+,;=]/g, '')
         .toLowerCase();
 }

package/dist/utils/options.d.ts

@@ -1,10 +1,11 @@
-import type { Snippet } from 'svelte';
+import type { IconProps } from '@lucide/svelte';
+import type { Component } from 'svelte';
+import type { InputProps } from '../input/type.ts';
 export type Option = {
     value: string;
     label: string;
-    icon?: string | Snippet;
-    disable?: boolean;
-};
+    icon?: Component<IconProps>;
+} & Omit<InputProps, 'id'>;
 export type OptionRecord<Values extends string> = Record<Values, Omit<Option, 'value'>>;
-export type Options = string | string[] | Option[] | Record<string, string> | OptionRecord<string>;
+export type Options = string | readonly string[] | readonly Option[] | Record<string, string> | OptionRecord<string>;
 export declare function parseOptions(options: Options): Option[];

package/dist/utils/options.js

@@ -1,7 +1,8 @@
-import { jsonParse } from './jsonParse.js';
+import z from 'zod';
+import { zodCoerceJsonValue } from '../validation/zod.ts';
 export function parseOptions(options) {
     if (typeof options === 'string') {
-        options = jsonParse(options, []);
+        options = zodCoerceJsonValue.pipe(z.array(z.string())).default([]).parse(options);
     }
     if (Array.isArray(options)) {
         return options.filter(Boolean).map((opt) => {

package/dist/utils/tippy.d.ts

@@ -1,5 +1,5 @@
 import 'tippy.js/dist/tippy.css';
-import { type Tippy, type Props as TippyProps, type Instance as TippyInstance, hideAll, delegate, createSingleton, animateFill, followCursor, inlinePositioning, sticky, roundArrow } from 'tippy.js';
+import { animateFill, createSingleton, delegate, followCursor, hideAll, inlinePositioning, roundArrow, sticky, type Tippy, type Instance as TippyInstance, type Props as TippyProps } from 'tippy.js';
 export declare const tippy: Tippy;
 export type { TippyProps, TippyInstance };
 export { hideAll, delegate, createSingleton, animateFill, followCursor, inlinePositioning, sticky, roundArrow };

package/dist/utils/tippy.js

@@ -1,4 +1,4 @@
 import 'tippy.js/dist/tippy.css';
-import tippyBadTyped, { hideAll, delegate, createSingleton, animateFill, followCursor, inlinePositioning, sticky, roundArrow } from 'tippy.js';
+import tippyBadTyped, { animateFill, createSingleton, delegate, followCursor, hideAll, inlinePositioning, roundArrow, sticky } from 'tippy.js';
 export const tippy = tippyBadTyped;
 export { hideAll, delegate, createSingleton, animateFill, followCursor, inlinePositioning, sticky, roundArrow };

package/dist/validation/index.d.ts

@@ -1,2 +1 @@
-export * from './form.js';
 export * from './zod.js';

package/dist/validation/index.js

@@ -1,2 +1 @@
-export * from './form.js';
 export * from './zod.js';

package/dist/validation/zod.d.ts

@@ -1,394 +1,13 @@
-import zod from 'zod';
-declare function json<T extends zod.ZodRawShape>(shap: T): zod.ZodUnion<readonly [zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>, zod.ZodPipe<zod.ZodPipe<zod.ZodString, zod.ZodTransform<zod.z.core.$RefinementCtx<string>, string>>, zod.z.core.$ZodType<any, zod.z.core.$RefinementCtx<string>, zod.z.core.$ZodTypeInternals<any, zod.z.core.$RefinementCtx<string>>>>]>;
-declare function jsonArray<T extends zod.ZodTypeAny>(shap: T): zod.ZodUnion<readonly [zod.ZodArray<T>, zod.ZodPipe<zod.ZodPipe<zod.ZodString, zod.ZodTransform<zod.z.core.$RefinementCtx<string>, string>>, zod.z.core.$ZodType<any, zod.z.core.$RefinementCtx<string>, zod.z.core.$ZodTypeInternals<any, zod.z.core.$RefinementCtx<string>>>>]>;
-type RelationsOperation = 'set' | 'disconnect' | 'delete' | 'connect';
-export declare const z: {
-    json: typeof json;
-    jsonArray: typeof jsonArray;
-    relation: {
-        connect: zod.ZodPipe<zod.ZodObject<{
-            id: zod.ZodString;
-        }, zod.z.core.$strip>, zod.ZodTransform<{
-            connect: {
-                id: string;
-            };
-        }, {
-            id: string;
-        }>>;
-        create<T extends zod.ZodRawShape>(shap: T): zod.ZodPipe<zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>, zod.ZodTransform<{
-            create: zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>;
-        }, zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>>>;
-        connectOrCreate<T extends zod.ZodRawShape>(shap: T): zod.ZodPipe<zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>, zod.ZodTransform<{
-            connectOrCreate: zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>;
-        }, zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>>>;
-        upsert<T extends zod.ZodRawShape>(shap: T): zod.ZodPipe<zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>, zod.ZodTransform<{
-            upsert: zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>;
-        }, zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>>>;
-        update<T extends zod.ZodRawShape>(shap: T): zod.ZodPipe<zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>, zod.ZodTransform<{
-            update: zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>;
-        }, zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>>>;
-    };
-    relations: {
-        set: zod.ZodPipe<zod.ZodArray<zod.ZodObject<{
-            id: zod.ZodString;
-        }, zod.z.core.$strip>>, zod.ZodTransform<Partial<Record<RelationsOperation, {
-            id: string;
-        }[]>>, {
-            id: string;
-        }[]>>;
-        disconnect: zod.ZodPipe<zod.ZodArray<zod.ZodObject<{
-            id: zod.ZodString;
-        }, zod.z.core.$strip>>, zod.ZodTransform<Partial<Record<RelationsOperation, {
-            id: string;
-        }[]>>, {
-            id: string;
-        }[]>>;
-        delete: zod.ZodPipe<zod.ZodArray<zod.ZodObject<{
-            id: zod.ZodString;
-        }, zod.z.core.$strip>>, zod.ZodTransform<Partial<Record<RelationsOperation, {
-            id: string;
-        }[]>>, {
-            id: string;
-        }[]>>;
-        connect: zod.ZodPipe<zod.ZodArray<zod.ZodObject<{
-            id: zod.ZodString;
-        }, zod.z.core.$strip>>, zod.ZodTransform<Partial<Record<RelationsOperation, {
-            id: string;
-        }[]>>, {
-            id: string;
-        }[]>>;
-        create<T extends zod.ZodRawShape>(shap: T): zod.ZodPipe<zod.ZodUnion<readonly [zod.ZodArray<zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>>, zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>]>, zod.ZodTransform<{
-            create: zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[];
-        }, zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[]>>;
-        connectOrCreate<T extends zod.ZodRawShape>(shap: T): zod.ZodPipe<zod.ZodUnion<readonly [zod.ZodArray<zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>>, zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>]>, zod.ZodTransform<{
-            connectOrCreate: zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[];
-        }, zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[]>>;
-        upsert<T extends zod.ZodRawShape>(shap: T): zod.ZodPipe<zod.ZodUnion<readonly [zod.ZodArray<zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>>, zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>]>, zod.ZodTransform<{
-            upsert: zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[];
-        }, zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[]>>;
-        createMany<T extends zod.ZodRawShape>(shap: T): zod.ZodPipe<zod.ZodUnion<readonly [zod.ZodArray<zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>>, zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>]>, zod.ZodTransform<{
-            createMany: zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[];
-        }, zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[]>>;
-        update<T extends zod.ZodRawShape>(shap: T): zod.ZodPipe<zod.ZodUnion<readonly [zod.ZodArray<zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>>, zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>]>, zod.ZodTransform<{
-            update: zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[];
-        }, zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[]>>;
-        updateMany<T extends zod.ZodRawShape>(shap: T): zod.ZodPipe<zod.ZodUnion<readonly [zod.ZodArray<zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>>, zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>]>, zod.ZodTransform<{
-            updateMany: zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[];
-        }, zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[]>>;
-        deleteMany<T extends zod.ZodRawShape>(shap: T): zod.ZodPipe<zod.ZodUnion<readonly [zod.ZodArray<zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>>, zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>]>, zod.ZodTransform<{
-            deleteMany: zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[];
-        }, zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[]>>;
-    };
-    filter: {
-        number: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodObject<{
-            min: zod.ZodOptional<zod.ZodNumber>;
-            max: zod.ZodOptional<zod.ZodNumber>;
-            order: zod.ZodOptional<zod.ZodEnum<{
-                desc: "desc";
-                asc: "asc";
-            }>>;
-        }, zod.z.core.$strip>, zod.ZodPipe<zod.ZodPipe<zod.ZodString, zod.ZodTransform<zod.z.core.$RefinementCtx<string>, string>>, zod.z.core.$ZodType<any, zod.z.core.$RefinementCtx<string>, zod.z.core.$ZodTypeInternals<any, zod.z.core.$RefinementCtx<string>>>>]>>;
-        multiselect: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodArray<zod.ZodString>, zod.ZodPipe<zod.ZodPipe<zod.ZodString, zod.ZodTransform<zod.z.core.$RefinementCtx<string>, string>>, zod.z.core.$ZodType<any, zod.z.core.$RefinementCtx<string>, zod.z.core.$ZodTypeInternals<any, zod.z.core.$RefinementCtx<string>>>>]>>;
-        range: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodObject<{
-            start: zod.ZodOptional<zod.z.ZodCoercedDate<unknown>>;
-            end: zod.ZodOptional<zod.z.ZodCoercedDate<unknown>>;
-            order: zod.ZodOptional<zod.ZodEnum<{
-                desc: "desc";
-                asc: "asc";
-            }>>;
-        }, zod.z.core.$strip>, zod.ZodPipe<zod.ZodPipe<zod.ZodString, zod.ZodTransform<zod.z.core.$RefinementCtx<string>, string>>, zod.z.core.$ZodType<any, zod.z.core.$RefinementCtx<string>, zod.z.core.$ZodTypeInternals<any, zod.z.core.$RefinementCtx<string>>>>]>>;
-        boolean: zod.ZodOptional<zod.ZodPipe<zod.ZodEnum<{
-            true: "true";
-            false: "false";
-        }>, zod.ZodTransform<boolean, "true" | "false">>>;
-    };
-    z: typeof zod.z;
-    default: typeof zod.z;
-    core: typeof zod.z.core;
-    globalRegistry: zod.z.core.$ZodRegistry<zod.z.core.GlobalMeta, zod.z.core.$ZodType<unknown, unknown, zod.z.core.$ZodTypeInternals<unknown, unknown>>>;
-    registry: typeof zod.z.core.registry;
-    config: typeof zod.z.core.config;
-    $output: typeof zod.z.core.$output;
-    $input: typeof zod.z.core.$input;
-    $brand: typeof zod.z.core.$brand;
-    clone: typeof zod.z.core.util.clone;
-    regexes: typeof zod.z.core.regexes;
-    treeifyError: typeof zod.z.core.treeifyError;
-    prettifyError: typeof zod.z.core.prettifyError;
-    formatError: typeof zod.z.core.formatError;
-    flattenError: typeof zod.z.core.flattenError;
-    toJSONSchema: typeof zod.z.core.toJSONSchema;
-    TimePrecision: {
-        readonly Any: null;
-        readonly Minute: -1;
-        readonly Second: 0;
-        readonly Millisecond: 3;
-        readonly Microsecond: 6;
-    };
-    util: typeof zod.z.core.util;
-    NEVER: never;
-    locales: typeof zod.z.core.locales;
-    ZodISODateTime: zod.z.core.$constructor<zod.z.ZodISODateTime, zod.z.core.$ZodISODateTimeDef>;
-    ZodISODate: zod.z.core.$constructor<zod.z.ZodISODate, zod.z.core.$ZodStringFormatDef<"date">>;
-    ZodISOTime: zod.z.core.$constructor<zod.z.ZodISOTime, zod.z.core.$ZodISOTimeDef>;
-    ZodISODuration: zod.z.core.$constructor<zod.z.ZodISODuration, zod.z.core.$ZodStringFormatDef<"duration">>;
-    iso: typeof zod.z.iso;
-    coerce: typeof zod.z.coerce;
-    string(params?: string | zod.z.core.$ZodStringParams): zod.ZodString;
-    string<T extends string>(params?: string | zod.z.core.$ZodStringParams): zod.z.core.$ZodType<T, T>;
-    email(params?: string | zod.z.core.$ZodEmailParams): zod.ZodEmail;
-    guid(params?: string | zod.z.core.$ZodGUIDParams): zod.ZodGUID;
-    uuid(params?: string | zod.z.core.$ZodUUIDParams): zod.ZodUUID;
-    uuidv4(params?: string | zod.z.core.$ZodUUIDv4Params): zod.ZodUUID;
-    uuidv6(params?: string | zod.z.core.$ZodUUIDv6Params): zod.ZodUUID;
-    uuidv7(params?: string | zod.z.core.$ZodUUIDv7Params): zod.ZodUUID;
-    url(params?: string | zod.z.core.$ZodURLParams): zod.ZodURL;
-    httpUrl(params?: string | Omit<zod.z.core.$ZodURLParams, "protocol" | "hostname">): zod.ZodURL;
-    emoji(params?: string | zod.z.core.$ZodEmojiParams): zod.ZodEmoji;
-    nanoid(params?: string | zod.z.core.$ZodNanoIDParams): zod.ZodNanoID;
-    cuid(params?: string | zod.z.core.$ZodCUIDParams): zod.ZodCUID;
-    cuid2(params?: string | zod.z.core.$ZodCUID2Params): zod.ZodCUID2;
-    ulid(params?: string | zod.z.core.$ZodULIDParams): zod.ZodULID;
-    xid(params?: string | zod.z.core.$ZodXIDParams): zod.ZodXID;
-    ksuid(params?: string | zod.z.core.$ZodKSUIDParams): zod.ZodKSUID;
-    ipv4(params?: string | zod.z.core.$ZodIPv4Params): zod.ZodIPv4;
-    ipv6(params?: string | zod.z.core.$ZodIPv6Params): zod.ZodIPv6;
-    cidrv4(params?: string | zod.z.core.$ZodCIDRv4Params): zod.ZodCIDRv4;
-    cidrv6(params?: string | zod.z.core.$ZodCIDRv6Params): zod.ZodCIDRv6;
-    base64(params?: string | zod.z.core.$ZodBase64Params): zod.ZodBase64;
-    base64url(params?: string | zod.z.core.$ZodBase64URLParams): zod.ZodBase64URL;
-    e164(params?: string | zod.z.core.$ZodE164Params): zod.ZodE164;
-    jwt(params?: string | zod.z.core.$ZodJWTParams): zod.ZodJWT;
-    stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => zod.z.core.util.MaybeAsync<unknown>) | RegExp, _params?: string | zod.z.core.$ZodStringFormatParams): zod.ZodCustomStringFormat<Format>;
-    hostname(_params?: string | zod.z.core.$ZodStringFormatParams): zod.ZodCustomStringFormat<"hostname">;
-    hex(_params?: string | zod.z.core.$ZodStringFormatParams): zod.ZodCustomStringFormat<"hex">;
-    hash<Alg extends zod.z.core.util.HashAlgorithm, Enc extends zod.z.core.util.HashEncoding = "hex">(alg: Alg, params?: {
-        enc?: Enc;
-    } & zod.z.core.$ZodStringFormatParams): zod.ZodCustomStringFormat<`${Alg}_${Enc}`>;
-    number(params?: string | zod.z.core.$ZodNumberParams): zod.ZodNumber;
-    int(params?: string | zod.z.core.$ZodCheckNumberFormatParams): zod.ZodInt;
-    float32(params?: string | zod.z.core.$ZodCheckNumberFormatParams): zod.ZodFloat32;
-    float64(params?: string | zod.z.core.$ZodCheckNumberFormatParams): zod.ZodFloat64;
-    int32(params?: string | zod.z.core.$ZodCheckNumberFormatParams): zod.ZodInt32;
-    uint32(params?: string | zod.z.core.$ZodCheckNumberFormatParams): zod.ZodUInt32;
-    boolean(params?: string | zod.z.core.$ZodBooleanParams): zod.ZodBoolean;
-    bigint(params?: string | zod.z.core.$ZodBigIntParams): zod.ZodBigInt;
-    int64(params?: string | zod.z.core.$ZodBigIntFormatParams): zod.ZodBigIntFormat;
-    uint64(params?: string | zod.z.core.$ZodBigIntFormatParams): zod.ZodBigIntFormat;
-    symbol(params?: string | zod.z.core.$ZodSymbolParams): zod.ZodSymbol;
-    any(): zod.ZodAny;
-    unknown(): zod.ZodUnknown;
-    never(params?: string | zod.z.core.$ZodNeverParams): zod.ZodNever;
-    date(params?: string | zod.z.core.$ZodDateParams): zod.ZodDate;
-    array<T extends zod.z.core.SomeType>(element: T, params?: string | zod.z.core.$ZodArrayParams): zod.ZodArray<T>;
-    keyof<T extends zod.ZodObject>(schema: T): zod.ZodEnum<zod.z.core.util.KeysEnum<T["_zod"]["output"]>>;
-    object<T extends zod.z.core.$ZodLooseShape = Partial<Record<never, zod.z.core.SomeType>>>(shape?: T, params?: string | zod.z.core.$ZodObjectParams): zod.ZodObject<zod.z.core.util.Writeable<T>, zod.z.core.$strip>;
-    strictObject<T extends zod.z.core.$ZodLooseShape>(shape: T, params?: string | zod.z.core.$ZodObjectParams): zod.ZodObject<T, zod.z.core.$strict>;
-    looseObject<T extends zod.z.core.$ZodLooseShape>(shape: T, params?: string | zod.z.core.$ZodObjectParams): zod.ZodObject<T, zod.z.core.$loose>;
-    union<const T extends readonly zod.z.core.SomeType[]>(options: T, params?: string | zod.z.core.$ZodUnionParams): zod.ZodUnion<T>;
-    discriminatedUnion<Types extends readonly [zod.z.core.$ZodTypeDiscriminable, ...zod.z.core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | zod.z.core.$ZodDiscriminatedUnionParams): zod.ZodDiscriminatedUnion<Types, Disc>;
-    intersection<T extends zod.z.core.SomeType, U extends zod.z.core.SomeType>(left: T, right: U): zod.ZodIntersection<T, U>;
-    tuple<T extends readonly [zod.z.core.SomeType, ...zod.z.core.SomeType[]]>(items: T, params?: string | zod.z.core.$ZodTupleParams): zod.ZodTuple<T, null>;
-    tuple<T extends readonly [zod.z.core.SomeType, ...zod.z.core.SomeType[]], Rest extends zod.z.core.SomeType>(items: T, rest: Rest, params?: string | zod.z.core.$ZodTupleParams): zod.ZodTuple<T, Rest>;
-    tuple(items: [], params?: string | zod.z.core.$ZodTupleParams): zod.ZodTuple<[], null>;
-    record<Key extends zod.z.core.$ZodRecordKey, Value extends zod.z.core.SomeType>(keyType: Key, valueType: Value, params?: string | zod.z.core.$ZodRecordParams): zod.ZodRecord<Key, Value>;
-    partialRecord<Key extends zod.z.core.$ZodRecordKey, Value extends zod.z.core.SomeType>(keyType: Key, valueType: Value, params?: string | zod.z.core.$ZodRecordParams): zod.ZodRecord<Key & zod.z.core.$partial, Value>;
-    map<Key extends zod.z.core.SomeType, Value extends zod.z.core.SomeType>(keyType: Key, valueType: Value, params?: string | zod.z.core.$ZodMapParams): zod.ZodMap<Key, Value>;
-    set<Value extends zod.z.core.SomeType>(valueType: Value, params?: string | zod.z.core.$ZodSetParams): zod.ZodSet<Value>;
-    nativeEnum<T extends zod.z.core.util.EnumLike>(entries: T, params?: string | zod.z.core.$ZodEnumParams): zod.ZodEnum<T>;
-    literal<const T extends ReadonlyArray<zod.z.core.util.Literal>>(value: T, params?: string | zod.z.core.$ZodLiteralParams): zod.ZodLiteral<T[number]>;
-    literal<const T extends zod.z.core.util.Literal>(value: T, params?: string | zod.z.core.$ZodLiteralParams): zod.ZodLiteral<T>;
-    file(params?: string | zod.z.core.$ZodFileParams): zod.ZodFile;
-    transform<I = unknown, O = I>(fn: (input: I, ctx: zod.z.core.ParsePayload) => O): zod.ZodTransform<Awaited<O>, I>;
-    optional<T extends zod.z.core.SomeType>(innerType: T): zod.ZodOptional<T>;
-    nullable<T extends zod.z.core.SomeType>(innerType: T): zod.ZodNullable<T>;
-    nullish<T extends zod.z.core.SomeType>(innerType: T): zod.ZodOptional<zod.ZodNullable<T>>;
-    _default<T extends zod.z.core.SomeType>(innerType: T, defaultValue: zod.z.core.util.NoUndefined<zod.z.core.output<T>> | (() => zod.z.core.util.NoUndefined<zod.z.core.output<T>>)): zod.ZodDefault<T>;
-    prefault<T extends zod.z.core.SomeType>(innerType: T, defaultValue: zod.z.core.input<T> | (() => zod.z.core.input<T>)): zod.ZodPrefault<T>;
-    nonoptional<T extends zod.z.core.SomeType>(innerType: T, params?: string | zod.z.core.$ZodNonOptionalParams): zod.ZodNonOptional<T>;
-    success<T extends zod.z.core.SomeType>(innerType: T): zod.ZodSuccess<T>;
-    nan(params?: string | zod.z.core.$ZodNaNParams): zod.ZodNaN;
-    pipe<const A extends zod.z.core.SomeType, B extends zod.z.core.$ZodType<unknown, zod.z.core.output<A>> = zod.z.core.$ZodType<unknown, zod.z.core.output<A>, zod.z.core.$ZodTypeInternals<unknown, zod.z.core.output<A>>>>(in_: A, out: B | zod.z.core.$ZodType<unknown, zod.z.core.output<A>>): zod.ZodPipe<A, B>;
-    codec<const A extends zod.z.core.SomeType, B extends zod.z.core.SomeType = zod.z.core.$ZodType<unknown, unknown, zod.z.core.$ZodTypeInternals<unknown, unknown>>>(in_: A, out: B, params: {
-        decode: (value: zod.z.core.output<A>, payload: zod.z.core.ParsePayload<zod.z.core.output<A>>) => zod.z.core.util.MaybeAsync<zod.z.core.input<B>>;
-        encode: (value: zod.z.core.input<B>, payload: zod.z.core.ParsePayload<zod.z.core.input<B>>) => zod.z.core.util.MaybeAsync<zod.z.core.output<A>>;
-    }): zod.ZodCodec<A, B>;
-    readonly<T extends zod.z.core.SomeType>(innerType: T): zod.ZodReadonly<T>;
-    templateLiteral<const Parts extends zod.z.core.$ZodTemplateLiteralPart[]>(parts: Parts, params?: string | zod.z.core.$ZodTemplateLiteralParams): zod.ZodTemplateLiteral<zod.z.core.$PartsToTemplateLiteral<Parts>>;
-    lazy<T extends zod.z.core.SomeType>(getter: () => T): zod.ZodLazy<T>;
-    promise<T extends zod.z.core.SomeType>(innerType: T): zod.ZodPromise<T>;
-    _function(): zod.ZodFunction;
-    _function<const In extends ReadonlyArray<zod.z.core.$ZodType>>(params: {
-        input: In;
-    }): zod.ZodFunction<zod.ZodTuple<In, null>, zod.z.core.$ZodFunctionOut>;
-    _function<const In extends ReadonlyArray<zod.z.core.$ZodType>, const Out extends zod.z.core.$ZodFunctionOut = zod.z.core.$ZodFunctionOut>(params: {
-        input: In;
-        output: Out;
-    }): zod.ZodFunction<zod.ZodTuple<In, null>, Out>;
-    _function<const In extends zod.z.core.$ZodFunctionIn = zod.z.core.$ZodFunctionArgs>(params: {
-        input: In;
-    }): zod.ZodFunction<In, zod.z.core.$ZodFunctionOut>;
-    _function<const Out extends zod.z.core.$ZodFunctionOut = zod.z.core.$ZodFunctionOut>(params: {
-        output: Out;
-    }): zod.ZodFunction<zod.z.core.$ZodFunctionIn, Out>;
-    _function<In extends zod.z.core.$ZodFunctionIn = zod.z.core.$ZodFunctionArgs, Out extends zod.z.core.$ZodType = zod.z.core.$ZodType<unknown, unknown, zod.z.core.$ZodTypeInternals<unknown, unknown>>>(params?: {
-        input: In;
-        output: Out;
-    }): zod.ZodFunction<In, Out>;
-    check<O = unknown>(fn: zod.z.core.CheckFn<O>): zod.z.core.$ZodCheck<O>;
-    custom<O>(fn?: (data: unknown) => unknown, _params?: string | zod.z.core.$ZodCustomParams | undefined): zod.ZodCustom<O, O>;
-    refine<T>(fn: (arg: NoInfer<T>) => zod.z.core.util.MaybeAsync<unknown>, _params?: string | zod.z.core.$ZodCustomParams): zod.z.core.$ZodCheck<T>;
-    superRefine<T>(fn: (arg: T, payload: zod.z.core.$RefinementCtx<T>) => void | Promise<void>): zod.z.core.$ZodCheck<T>;
-    preprocess<A, U extends zod.z.core.SomeType, B = unknown>(fn: (arg: B, ctx: zod.z.core.$RefinementCtx) => A, schema: U): zod.ZodPipe<zod.ZodTransform<A, B>, U>;
-    ZodType: zod.z.core.$constructor<zod.ZodType>;
-    _ZodString: zod.z.core.$constructor<zod._ZodString>;
-    ZodString: zod.z.core.$constructor<zod.ZodString>;
-    ZodStringFormat: zod.z.core.$constructor<zod.ZodStringFormat>;
-    ZodEmail: zod.z.core.$constructor<zod.ZodEmail>;
-    ZodGUID: zod.z.core.$constructor<zod.ZodGUID>;
-    ZodUUID: zod.z.core.$constructor<zod.ZodUUID>;
-    ZodURL: zod.z.core.$constructor<zod.ZodURL>;
-    ZodEmoji: zod.z.core.$constructor<zod.ZodEmoji>;
-    ZodNanoID: zod.z.core.$constructor<zod.ZodNanoID>;
-    ZodCUID: zod.z.core.$constructor<zod.ZodCUID>;
-    ZodCUID2: zod.z.core.$constructor<zod.ZodCUID2>;
-    ZodULID: zod.z.core.$constructor<zod.ZodULID>;
-    ZodXID: zod.z.core.$constructor<zod.ZodXID>;
-    ZodKSUID: zod.z.core.$constructor<zod.ZodKSUID>;
-    ZodIPv4: zod.z.core.$constructor<zod.ZodIPv4>;
-    ZodIPv6: zod.z.core.$constructor<zod.ZodIPv6>;
-    ZodCIDRv4: zod.z.core.$constructor<zod.ZodCIDRv4>;
-    ZodCIDRv6: zod.z.core.$constructor<zod.ZodCIDRv6>;
-    ZodBase64: zod.z.core.$constructor<zod.ZodBase64>;
-    ZodBase64URL: zod.z.core.$constructor<zod.ZodBase64URL>;
-    ZodE164: zod.z.core.$constructor<zod.ZodE164>;
-    ZodJWT: zod.z.core.$constructor<zod.ZodJWT>;
-    ZodCustomStringFormat: zod.z.core.$constructor<zod.ZodCustomStringFormat>;
-    ZodNumber: zod.z.core.$constructor<zod.ZodNumber>;
-    ZodNumberFormat: zod.z.core.$constructor<zod.ZodNumberFormat>;
-    ZodBoolean: zod.z.core.$constructor<zod.ZodBoolean>;
-    ZodBigInt: zod.z.core.$constructor<zod.ZodBigInt>;
-    ZodBigIntFormat: zod.z.core.$constructor<zod.ZodBigIntFormat>;
-    ZodSymbol: zod.z.core.$constructor<zod.ZodSymbol>;
-    ZodUndefined: zod.z.core.$constructor<zod.ZodUndefined>;
-    undefined: typeof zod.z.undefined;
-    ZodNull: zod.z.core.$constructor<zod.ZodNull>;
-    null: typeof zod.z.null;
-    ZodAny: zod.z.core.$constructor<zod.ZodAny>;
-    ZodUnknown: zod.z.core.$constructor<zod.ZodUnknown>;
-    ZodNever: zod.z.core.$constructor<zod.ZodNever>;
-    ZodVoid: zod.z.core.$constructor<zod.ZodVoid>;
-    void: typeof zod.z.void;
-    ZodDate: zod.z.core.$constructor<zod.ZodDate>;
-    ZodArray: zod.z.core.$constructor<zod.ZodArray>;
-    ZodObject: zod.z.core.$constructor<zod.ZodObject>;
-    ZodUnion: zod.z.core.$constructor<zod.ZodUnion>;
-    ZodDiscriminatedUnion: zod.z.core.$constructor<zod.ZodDiscriminatedUnion>;
-    ZodIntersection: zod.z.core.$constructor<zod.ZodIntersection>;
-    ZodTuple: zod.z.core.$constructor<zod.ZodTuple>;
-    ZodRecord: zod.z.core.$constructor<zod.ZodRecord>;
-    ZodMap: zod.z.core.$constructor<zod.ZodMap>;
-    ZodSet: zod.z.core.$constructor<zod.ZodSet>;
-    ZodEnum: zod.z.core.$constructor<zod.ZodEnum>;
-    enum: typeof zod.z.enum;
-    ZodLiteral: zod.z.core.$constructor<zod.ZodLiteral>;
-    ZodFile: zod.z.core.$constructor<zod.ZodFile>;
-    ZodTransform: zod.z.core.$constructor<zod.ZodTransform>;
-    ZodOptional: zod.z.core.$constructor<zod.ZodOptional>;
-    ZodNullable: zod.z.core.$constructor<zod.ZodNullable>;
-    ZodDefault: zod.z.core.$constructor<zod.ZodDefault>;
-    ZodPrefault: zod.z.core.$constructor<zod.ZodPrefault>;
-    ZodNonOptional: zod.z.core.$constructor<zod.ZodNonOptional>;
-    ZodSuccess: zod.z.core.$constructor<zod.ZodSuccess>;
-    ZodCatch: zod.z.core.$constructor<zod.ZodCatch>;
-    catch: typeof zod.z.catch;
-    ZodNaN: zod.z.core.$constructor<zod.ZodNaN>;
-    ZodPipe: zod.z.core.$constructor<zod.ZodPipe>;
-    ZodCodec: zod.z.core.$constructor<zod.ZodCodec>;
-    ZodReadonly: zod.z.core.$constructor<zod.ZodReadonly>;
-    ZodTemplateLiteral: zod.z.core.$constructor<zod.ZodTemplateLiteral>;
-    ZodLazy: zod.z.core.$constructor<zod.ZodLazy>;
-    ZodPromise: zod.z.core.$constructor<zod.ZodPromise>;
-    ZodFunction: zod.z.core.$constructor<zod.ZodFunction>;
-    function: typeof zod._function;
-    ZodCustom: zod.z.core.$constructor<zod.ZodCustom>;
-    instanceof: typeof zod.z.instanceof;
-    stringbool: (_params?: string | zod.z.core.$ZodStringBoolParams) => zod.ZodCodec<zod.ZodString, zod.ZodBoolean>;
-    lt: typeof zod.z.core._lt;
-    lte: typeof zod.z.core._lte;
-    gt: typeof zod.z.core._gt;
-    gte: typeof zod.z.core._gte;
-    positive: typeof zod.z.core._positive;
-    negative: typeof zod.z.core._negative;
-    nonpositive: typeof zod.z.core._nonpositive;
-    nonnegative: typeof zod.z.core._nonnegative;
-    multipleOf: typeof zod.z.core._multipleOf;
-    maxSize: typeof zod.z.core._maxSize;
-    minSize: typeof zod.z.core._minSize;
-    size: typeof zod.z.core._size;
-    maxLength: typeof zod.z.core._maxLength;
-    minLength: typeof zod.z.core._minLength;
-    length: typeof zod.z.core._length;
-    regex: typeof zod.z.core._regex;
-    lowercase: typeof zod.z.core._lowercase;
-    uppercase: typeof zod.z.core._uppercase;
-    includes: typeof zod.z.core._includes;
-    startsWith: typeof zod.z.core._startsWith;
-    endsWith: typeof zod.z.core._endsWith;
-    property: typeof zod.z.core._property;
-    mime: typeof zod.z.core._mime;
-    overwrite: typeof zod.z.core._overwrite;
-    normalize: typeof zod.z.core._normalize;
-    trim: typeof zod.z.core._trim;
-    toLowerCase: typeof zod.z.core._toLowerCase;
-    toUpperCase: typeof zod.z.core._toUpperCase;
-    ZodError: zod.z.core.$constructor<zod.ZodError>;
-    ZodRealError: zod.z.core.$constructor<zod.ZodError>;
-    parse: <T extends zod.z.core.$ZodType>(schema: T, value: unknown, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>, _params?: {
-        callee?: zod.z.core.util.AnyFunc;
-        Err?: zod.z.core.$ZodErrorClass;
-    }) => zod.z.core.output<T>;
-    parseAsync: <T extends zod.z.core.$ZodType>(schema: T, value: unknown, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>, _params?: {
-        callee?: zod.z.core.util.AnyFunc;
-        Err?: zod.z.core.$ZodErrorClass;
-    }) => Promise<zod.z.core.output<T>>;
-    safeParse: <T extends zod.z.core.$ZodType>(schema: T, value: unknown, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>) => zod.ZodSafeParseResult<zod.z.core.output<T>>;
-    safeParseAsync: <T extends zod.z.core.$ZodType>(schema: T, value: unknown, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>) => Promise<zod.ZodSafeParseResult<zod.z.core.output<T>>>;
-    encode: <T extends zod.z.core.$ZodType>(schema: T, value: zod.z.core.output<T>, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>) => zod.z.core.input<T>;
-    decode: <T extends zod.z.core.$ZodType>(schema: T, value: zod.z.core.input<T>, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>) => zod.z.core.output<T>;
-    encodeAsync: <T extends zod.z.core.$ZodType>(schema: T, value: zod.z.core.output<T>, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>) => Promise<zod.z.core.input<T>>;
-    decodeAsync: <T extends zod.z.core.$ZodType>(schema: T, value: zod.z.core.input<T>, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>) => Promise<zod.z.core.output<T>>;
-    safeEncode: <T extends zod.z.core.$ZodType>(schema: T, value: zod.z.core.output<T>, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>) => zod.ZodSafeParseResult<zod.z.core.input<T>>;
-    safeDecode: <T extends zod.z.core.$ZodType>(schema: T, value: zod.z.core.input<T>, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>) => zod.ZodSafeParseResult<zod.z.core.output<T>>;
-    safeEncodeAsync: <T extends zod.z.core.$ZodType>(schema: T, value: zod.z.core.output<T>, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>) => Promise<zod.ZodSafeParseResult<zod.z.core.input<T>>>;
-    safeDecodeAsync: <T extends zod.z.core.$ZodType>(schema: T, value: zod.z.core.input<T>, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>) => Promise<zod.ZodSafeParseResult<zod.z.core.output<T>>>;
-    setErrorMap(map: zod.z.core.$ZodErrorMap): void;
-    getErrorMap(): zod.z.core.$ZodErrorMap<zod.z.core.$ZodIssue> | undefined;
-    ZodIssueCode: {
-        readonly invalid_type: "invalid_type";
-        readonly too_big: "too_big";
-        readonly too_small: "too_small";
-        readonly invalid_format: "invalid_format";
-        readonly not_multiple_of: "not_multiple_of";
-        readonly unrecognized_keys: "unrecognized_keys";
-        readonly invalid_union: "invalid_union";
-        readonly invalid_key: "invalid_key";
-        readonly invalid_element: "invalid_element";
-        readonly invalid_value: "invalid_value";
-        readonly custom: "custom";
-    };
-    ZodFirstPartyTypeKind: typeof zod.ZodFirstPartyTypeKind;
+import z from 'zod';
+export type ShapeOf<T extends Record<string, unknown>> = Readonly<Readonly<{
+    [K in keyof T]: z.core.$ZodType<T[K], unknown, z.core.$ZodTypeInternals<T[K], unknown>>;
+}>>;
+export type JsonValue = string | number | boolean | null | JsonValue[] | JsonRecord;
+export type JsonRecord = {
+    [key: string]: JsonValue;
 };
-export type ZodInfer<T extends zod.ZodType<any, any, any>> = T['_output'];
-export type SuperRefinement<T> = zod.SuperRefinement<T>;
-/**
- * @example type MyModel = {name: z.string()} satisfies ZodObj<{name: string}>
- */
-export type ZodObj<T = Record<PropertyKey, unknown>> = {
-    [key in keyof T]: zod.ZodType<T[key], zod.ZodTypeDef, Date | boolean | number | string | undefined | null | object>;
-};
-export declare const toTuple: <T extends {}>(o: T) => UnionToTuple<keyof T>;
-type UnionToIntersection<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
-type LastInUnion<U> = UnionToIntersection<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
-export type UnionToTuple<U, Last = LastInUnion<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, Last>>, Last];
-export {};
+export declare const zodJsonValue: z.core.$ZodType<JsonValue>;
+export declare const zodJsonRecord: z.core.$ZodType<JsonRecord>;
+export declare const zodCoerceJson: z.ZodPipe<z.ZodString, z.ZodTransform<any, string>>;
+export declare const zodCoerceJsonValue: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<any, string>>, z.z.core.$ZodType<JsonValue, unknown, z.z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+export declare const zodCoerceJsonRecord: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<any, string>>, z.z.core.$ZodType<JsonRecord, unknown, z.z.core.$ZodTypeInternals<JsonRecord, unknown>>>;