fuma 2.0.0 → 2.0.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/private/model.d.ts +22 -30
- package/dist/server/formAction.d.ts +2 -3
- package/dist/server/formAction.js +1 -1
- package/dist/server/parseFormData.d.ts +3 -3
- package/dist/server/parseFormData.js +4 -2
- package/dist/server/parseQuery.d.ts +2 -2
- package/dist/server/parseQuery.js +1 -1
- package/dist/ui/form/Form.svelte +3 -3
- package/dist/ui/form/Form.svelte.d.ts +4 -4
- package/dist/ui/form/form.d.ts +1 -1
- package/dist/ui/input/InputImagePreview.svelte +1 -1
- package/dist/ui/input/textRich/InputTextRich.svelte +1 -1
- package/dist/ui/input/textRich/ToolMenu.svelte +1 -1
- package/dist/ui/table/TableViewSelect.svelte +1 -1
- package/dist/validation/zod.d.ts +331 -285
- package/package.json +3 -3
package/dist/private/model.d.ts
CHANGED
|
@@ -9,45 +9,37 @@ export declare const modelPost: {
|
|
|
9
9
|
viewCounter: import("zod").ZodOptional<import("zod").ZodNumber>;
|
|
10
10
|
publishedAt: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodDate>>;
|
|
11
11
|
publishedAtTime: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodDate>>;
|
|
12
|
-
publication: import("zod").ZodEnum<
|
|
13
|
-
|
|
12
|
+
publication: import("zod").ZodEnum<{
|
|
13
|
+
private: "private";
|
|
14
|
+
friends: "friends";
|
|
15
|
+
public: "public";
|
|
16
|
+
}>;
|
|
17
|
+
type: import("zod").ZodPipe<import("zod").ZodObject<{
|
|
14
18
|
id: import("zod").ZodString;
|
|
15
|
-
}, "strip
|
|
16
|
-
id: string;
|
|
17
|
-
}, {
|
|
18
|
-
id: string;
|
|
19
|
-
}>, {
|
|
19
|
+
}, import("zod/v4/core").$strip>, import("zod").ZodTransform<{
|
|
20
20
|
connect: {
|
|
21
21
|
id: string;
|
|
22
22
|
};
|
|
23
23
|
}, {
|
|
24
24
|
id: string;
|
|
25
|
-
}
|
|
26
|
-
tags: import("zod").
|
|
25
|
+
}>>;
|
|
26
|
+
tags: import("zod").ZodPipe<import("zod").ZodArray<import("zod").ZodObject<{
|
|
27
27
|
id: import("zod").ZodString;
|
|
28
|
-
}, "strip
|
|
29
|
-
id: string;
|
|
30
|
-
}, {
|
|
31
|
-
id: string;
|
|
32
|
-
}>, "many">, Partial<Record<"set" | "delete" | "connect" | "disconnect", {
|
|
28
|
+
}, import("zod/v4/core").$strip>>, import("zod").ZodTransform<Partial<Record<"set" | "delete" | "connect" | "disconnect", {
|
|
33
29
|
id: string;
|
|
34
30
|
}[]>>, {
|
|
35
31
|
id: string;
|
|
36
|
-
}[]
|
|
32
|
+
}[]>>;
|
|
37
33
|
};
|
|
38
34
|
export declare const modelPostUpdate: {
|
|
39
35
|
id: import("zod").ZodString;
|
|
40
|
-
tags: import("zod").
|
|
36
|
+
tags: import("zod").ZodPipe<import("zod").ZodArray<import("zod").ZodObject<{
|
|
41
37
|
id: import("zod").ZodString;
|
|
42
|
-
}, "strip
|
|
43
|
-
id: string;
|
|
44
|
-
}, {
|
|
45
|
-
id: string;
|
|
46
|
-
}>, "many">, Partial<Record<"set" | "delete" | "connect" | "disconnect", {
|
|
38
|
+
}, import("zod/v4/core").$strip>>, import("zod").ZodTransform<Partial<Record<"set" | "delete" | "connect" | "disconnect", {
|
|
47
39
|
id: string;
|
|
48
40
|
}[]>>, {
|
|
49
41
|
id: string;
|
|
50
|
-
}[]
|
|
42
|
+
}[]>>;
|
|
51
43
|
title: import("zod").ZodString;
|
|
52
44
|
content: import("zod").ZodString;
|
|
53
45
|
isFavourite: import("zod").ZodBoolean;
|
|
@@ -58,20 +50,20 @@ export declare const modelPostUpdate: {
|
|
|
58
50
|
viewCounter: import("zod").ZodOptional<import("zod").ZodNumber>;
|
|
59
51
|
publishedAt: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodDate>>;
|
|
60
52
|
publishedAtTime: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodDate>>;
|
|
61
|
-
publication: import("zod").ZodEnum<
|
|
62
|
-
|
|
53
|
+
publication: import("zod").ZodEnum<{
|
|
54
|
+
private: "private";
|
|
55
|
+
friends: "friends";
|
|
56
|
+
public: "public";
|
|
57
|
+
}>;
|
|
58
|
+
type: import("zod").ZodPipe<import("zod").ZodObject<{
|
|
63
59
|
id: import("zod").ZodString;
|
|
64
|
-
}, "strip
|
|
65
|
-
id: string;
|
|
66
|
-
}, {
|
|
67
|
-
id: string;
|
|
68
|
-
}>, {
|
|
60
|
+
}, import("zod/v4/core").$strip>, import("zod").ZodTransform<{
|
|
69
61
|
connect: {
|
|
70
62
|
id: string;
|
|
71
63
|
};
|
|
72
64
|
}, {
|
|
73
65
|
id: string;
|
|
74
|
-
}
|
|
66
|
+
}>>;
|
|
75
67
|
};
|
|
76
68
|
export declare const modelTag: {
|
|
77
69
|
name: import("zod").ZodString;
|
|
@@ -1,11 +1,10 @@
|
|
|
1
1
|
import type { z } from 'zod';
|
|
2
2
|
import type { RequestEvent } from '@sveltejs/kit';
|
|
3
|
-
export declare function formAction<E extends RequestEvent, Shape extends z.
|
|
3
|
+
export declare function formAction<E extends RequestEvent, Shape extends z.core.$ZodShape = z.core.$ZodShape, ReturnType extends unknown = unknown>(shapes: Shape | Shape[], func: (arg: E & {
|
|
4
4
|
event: E;
|
|
5
|
-
data: z.
|
|
5
|
+
data: z.core.$InferObjectOutput<Shape, {}>;
|
|
6
6
|
formData: FormData;
|
|
7
7
|
}) => Promise<ReturnType>, options?: {
|
|
8
|
-
validation?: z.SuperRefinement<z.objectOutputType<Shape, z.ZodTypeAny>>;
|
|
9
8
|
redirectTo?: string | URL | ((res: ReturnType) => string | URL | undefined);
|
|
10
9
|
}): (event: E) => Promise<import("@sveltejs/kit").ActionFailure<{
|
|
11
10
|
message: string;
|
|
@@ -2,7 +2,7 @@ import { parseFormData } from './parseFormData.js';
|
|
|
2
2
|
import { tryOrFail } from './try.js';
|
|
3
3
|
export function formAction(shapes, func, options = {}) {
|
|
4
4
|
return (event) => tryOrFail(async () => {
|
|
5
|
-
const { data, formData } = await parseFormData(event.request, shapes
|
|
5
|
+
const { data, formData } = await parseFormData(event.request, shapes); //, options.validation)
|
|
6
6
|
return func({ ...event, event, data, formData });
|
|
7
7
|
}, options.redirectTo);
|
|
8
8
|
}
|
|
@@ -1,10 +1,10 @@
|
|
|
1
1
|
import z from 'zod';
|
|
2
|
-
export type Issue = z.ZodIssue & {
|
|
2
|
+
export type Issue = z.core.$ZodIssue & {
|
|
3
3
|
received: string;
|
|
4
4
|
expected: string;
|
|
5
5
|
unionErrors?: z.ZodError[];
|
|
6
6
|
};
|
|
7
|
-
export declare function parseFormData<Shape extends z.
|
|
8
|
-
data: z.
|
|
7
|
+
export declare function parseFormData<Shape extends z.core.$ZodShape>(requestOrFormData: Request | FormData, shapes: Shape | Shape[]): Promise<{
|
|
8
|
+
data: z.z.core.$InferObjectOutput<{ -readonly [P in keyof Shape]: Shape[P]; }, {}>;
|
|
9
9
|
formData: FormData;
|
|
10
10
|
}>;
|
|
@@ -1,10 +1,12 @@
|
|
|
1
1
|
import { USE_COERCE_BOOLEAN, USE_COERCE_DATE, USE_COERCE_JSON, USE_COERCE_NUMBER } from '../utils/constant.js';
|
|
2
2
|
import { jsonParse } from '../utils/jsonParse.js';
|
|
3
3
|
import z from 'zod';
|
|
4
|
-
export async function parseFormData(requestOrFormData, shapes
|
|
4
|
+
export async function parseFormData(requestOrFormData, shapes
|
|
5
|
+
//validation?: (arg: z.core.output<Shape>, ctx: z.core.$RefinementCtx<z.core.output<Shape>>) => void
|
|
6
|
+
) {
|
|
5
7
|
const formData = requestOrFormData instanceof Request ? await requestOrFormData.formData() : requestOrFormData;
|
|
6
8
|
const [firstShap, ...unionShaps] = Array.isArray(shapes) ? shapes : [shapes];
|
|
7
|
-
const shema = z.object(firstShap)
|
|
9
|
+
const shema = z.object(firstShap); //.superRefine(validation)
|
|
8
10
|
unionShaps.forEach((shap) => shema.or(z.object(shap)));
|
|
9
11
|
const formDataFlateObject = Object.fromEntries(formData);
|
|
10
12
|
const formDataFlateObjectCoerced = coerceFlateData(formDataFlateObject);
|
|
@@ -1,2 +1,2 @@
|
|
|
1
|
-
import
|
|
2
|
-
export declare function parseQuery<
|
|
1
|
+
import z from 'zod';
|
|
2
|
+
export declare function parseQuery<Shape extends z.core.$ZodShape>(url: URL, shape: Shape): z.z.core.$InferObjectOutput<{ -readonly [P in keyof Shape]: Shape[P]; }, {}>;
|
package/dist/ui/form/Form.svelte
CHANGED
|
@@ -6,7 +6,7 @@
|
|
|
6
6
|
<script
|
|
7
7
|
lang="ts"
|
|
8
8
|
generics="
|
|
9
|
-
Shape extends z.
|
|
9
|
+
Shape extends z.core.$ZodShape,
|
|
10
10
|
ReturnData extends Record<string, unknown> = FormDataInput<Shape>,
|
|
11
11
|
Data extends FormDataInput<Shape> = FormDataInput<Shape>
|
|
12
12
|
"
|
|
@@ -110,7 +110,7 @@
|
|
|
110
110
|
|
|
111
111
|
<form
|
|
112
112
|
method="post"
|
|
113
|
-
action="{action}{simpleAction ? '' : data
|
|
113
|
+
action="{action}{simpleAction ? '' : data?.id ? actionUpdate : actionCreate}"
|
|
114
114
|
enctype="multipart/form-data"
|
|
115
115
|
class="{klass} flex flex-col gap-4"
|
|
116
116
|
use:enhance
|
|
@@ -158,7 +158,7 @@
|
|
|
158
158
|
>
|
|
159
159
|
<button class="btn btn-primary" {disabled}> Valider </button>
|
|
160
160
|
<div class="grow"></div>
|
|
161
|
-
{#if !simpleAction && data
|
|
161
|
+
{#if !simpleAction && data?.id && actionDelete}
|
|
162
162
|
{@const formaction = `${action}${actionDelete}`}
|
|
163
163
|
<slot name="delete" {formaction}>
|
|
164
164
|
<ButtonDelete {formaction} {disabled}>Supprimer</ButtonDelete>
|
|
@@ -2,7 +2,7 @@ import type { z } from 'zod';
|
|
|
2
2
|
import type { FormDataInput } from './form.js';
|
|
3
3
|
import { type FormField, type FormSectionProps, type Nullable } from './form.js';
|
|
4
4
|
import { type UseFormOptions } from '../../validation/form.js';
|
|
5
|
-
declare class __sveltets_Render<Shape extends z.
|
|
5
|
+
declare class __sveltets_Render<Shape extends z.core.$ZodShape, ReturnData extends Record<string, unknown> = FormDataInput<Shape>, Data extends FormDataInput<Shape> = FormDataInput<Shape>> {
|
|
6
6
|
props(): {
|
|
7
7
|
class?: string;
|
|
8
8
|
classSection?: string;
|
|
@@ -45,12 +45,12 @@ declare class __sveltets_Render<Shape extends z.ZodRawShape, ReturnData extends
|
|
|
45
45
|
};
|
|
46
46
|
}
|
|
47
47
|
interface $$IsomorphicComponent {
|
|
48
|
-
new <Shape extends z.
|
|
48
|
+
new <Shape extends z.core.$ZodShape, ReturnData extends Record<string, unknown> = FormDataInput<Shape>, Data extends FormDataInput<Shape> = FormDataInput<Shape>>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Shape, ReturnData, Data>['props']> & {
|
|
49
49
|
children?: any;
|
|
50
50
|
}>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Shape, ReturnData, Data>['props']>, ReturnType<__sveltets_Render<Shape, ReturnData, Data>['events']>, ReturnType<__sveltets_Render<Shape, ReturnData, Data>['slots']>> & {
|
|
51
51
|
$$bindings?: ReturnType<__sveltets_Render<Shape, ReturnData, Data>['bindings']>;
|
|
52
52
|
} & ReturnType<__sveltets_Render<Shape, ReturnData, Data>['exports']>;
|
|
53
|
-
<Shape extends z.
|
|
53
|
+
<Shape extends z.core.$ZodShape, ReturnData extends Record<string, unknown> = FormDataInput<Shape>, Data extends FormDataInput<Shape> = FormDataInput<Shape>>(internal: unknown, props: ReturnType<__sveltets_Render<Shape, ReturnData, Data>['props']> & {
|
|
54
54
|
$$events?: ReturnType<__sveltets_Render<Shape, ReturnData, Data>['events']>;
|
|
55
55
|
$$slots?: ReturnType<__sveltets_Render<Shape, ReturnData, Data>['slots']>;
|
|
56
56
|
children?: any;
|
|
@@ -58,5 +58,5 @@ interface $$IsomorphicComponent {
|
|
|
58
58
|
z_$$bindings?: ReturnType<__sveltets_Render<any, any, any>['bindings']>;
|
|
59
59
|
}
|
|
60
60
|
declare const Form: $$IsomorphicComponent;
|
|
61
|
-
type Form<Shape extends z.
|
|
61
|
+
type Form<Shape extends z.core.$ZodShape, ReturnData extends Record<string, unknown> = FormDataInput<Shape>, Data extends FormDataInput<Shape> = FormDataInput<Shape>> = InstanceType<typeof Form<Shape, ReturnData, Data>>;
|
|
62
62
|
export default Form;
|
package/dist/ui/form/form.d.ts
CHANGED
|
@@ -12,7 +12,7 @@ export type Nullable<T> = {
|
|
|
12
12
|
[P in keyof T]?: T[P] | null;
|
|
13
13
|
};
|
|
14
14
|
export type BoolOrFunction<S extends Shape> = boolean | ((data: Nullable<FormDataInput<S>>) => unknown);
|
|
15
|
-
export type FormDataInput<S extends Shape> = z.ZodObject<S
|
|
15
|
+
export type FormDataInput<S extends Shape> = z.input<z.core.$ZodObject<S>>;
|
|
16
16
|
export type FormField<S extends Shape> = {
|
|
17
17
|
key: string & keyof S;
|
|
18
18
|
/** number col used by field */
|
|
@@ -58,7 +58,7 @@
|
|
|
58
58
|
{#if editor}
|
|
59
59
|
<ToolsBar {editor} class={classToolbar} />
|
|
60
60
|
{/if}
|
|
61
|
-
<div bind:this={element} class="min-h-
|
|
61
|
+
<div bind:this={element} class="min-h-80 p-4 pb-10"></div>
|
|
62
62
|
</div>
|
|
63
63
|
{#if key}
|
|
64
64
|
<input type="hidden" name={key} {value} />
|
|
@@ -42,7 +42,7 @@
|
|
|
42
42
|
<span class="text-sm font-light">{toolSelected.label}</span>
|
|
43
43
|
{/if}
|
|
44
44
|
</slot>
|
|
45
|
-
<Icon path={mdiChevronDown} size={20} class="translate-y-
|
|
45
|
+
<Icon path={mdiChevronDown} size={20} class="translate-y-px opacity-70" />
|
|
46
46
|
</button>
|
|
47
47
|
|
|
48
48
|
{#each tools as tool}
|
|
@@ -57,7 +57,7 @@
|
|
|
57
57
|
class="menu-item bordered btn-sm gap-1 rounded-lg border font-semibold opacity-90"
|
|
58
58
|
>
|
|
59
59
|
<span>{isNewView ? 'Nouvelle vue' : selectedView?.name || 'Vue simple'}</span>
|
|
60
|
-
<Icon path={mdiChevronDown} size={20} class="translate-x-1 translate-y-
|
|
60
|
+
<Icon path={mdiChevronDown} size={20} class="translate-x-1 translate-y-px opacity-90" />
|
|
61
61
|
</button>
|
|
62
62
|
|
|
63
63
|
<ul class="flex flex-col gap-1">
|
package/dist/validation/zod.d.ts
CHANGED
|
@@ -1,329 +1,375 @@
|
|
|
1
1
|
import zod from 'zod';
|
|
2
|
-
declare function json<T extends zod.ZodRawShape>(shap: T): zod.ZodUnion<[zod.ZodObject<
|
|
3
|
-
declare function jsonArray<T extends zod.ZodTypeAny>(shap: T): zod.ZodUnion<[zod.ZodArray<T
|
|
2
|
+
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>>>>]>;
|
|
3
|
+
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>>>>]>;
|
|
4
4
|
type RelationsOperation = 'set' | 'disconnect' | 'delete' | 'connect';
|
|
5
5
|
export declare const z: {
|
|
6
6
|
json: typeof json;
|
|
7
7
|
jsonArray: typeof jsonArray;
|
|
8
8
|
relation: {
|
|
9
|
-
connect: zod.
|
|
9
|
+
connect: zod.ZodPipe<zod.ZodObject<{
|
|
10
10
|
id: zod.ZodString;
|
|
11
|
-
},
|
|
12
|
-
id: string;
|
|
13
|
-
}, {
|
|
14
|
-
id: string;
|
|
15
|
-
}>, {
|
|
11
|
+
}, zod.z.core.$strip>, zod.ZodTransform<{
|
|
16
12
|
connect: {
|
|
17
13
|
id: string;
|
|
18
14
|
};
|
|
19
15
|
}, {
|
|
20
16
|
id: string;
|
|
21
|
-
}
|
|
22
|
-
create<T extends zod.ZodRawShape>(shap: T): zod.
|
|
23
|
-
create: zod.
|
|
24
|
-
}, zod.
|
|
25
|
-
connectOrCreate<T extends zod.ZodRawShape>(shap: T): zod.
|
|
26
|
-
connectOrCreate: zod.
|
|
27
|
-
}, zod.
|
|
28
|
-
upsert<T extends zod.ZodRawShape>(shap: T): zod.
|
|
29
|
-
upsert: zod.
|
|
30
|
-
}, zod.
|
|
31
|
-
update<T extends zod.ZodRawShape>(shap: T): zod.
|
|
32
|
-
update: zod.
|
|
33
|
-
}, zod.
|
|
17
|
+
}>>;
|
|
18
|
+
create<T extends zod.ZodRawShape>(shap: T): zod.ZodPipe<zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>, zod.ZodTransform<{
|
|
19
|
+
create: zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>;
|
|
20
|
+
}, zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>>>;
|
|
21
|
+
connectOrCreate<T extends zod.ZodRawShape>(shap: T): zod.ZodPipe<zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>, zod.ZodTransform<{
|
|
22
|
+
connectOrCreate: zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>;
|
|
23
|
+
}, zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>>>;
|
|
24
|
+
upsert<T extends zod.ZodRawShape>(shap: T): zod.ZodPipe<zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>, zod.ZodTransform<{
|
|
25
|
+
upsert: zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>;
|
|
26
|
+
}, zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>>>;
|
|
27
|
+
update<T extends zod.ZodRawShape>(shap: T): zod.ZodPipe<zod.ZodObject<{ -readonly [P in keyof T]: T[P]; }, zod.z.core.$strip>, zod.ZodTransform<{
|
|
28
|
+
update: zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>;
|
|
29
|
+
}, zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>>>;
|
|
34
30
|
};
|
|
35
31
|
relations: {
|
|
36
|
-
set: zod.
|
|
32
|
+
set: zod.ZodPipe<zod.ZodArray<zod.ZodObject<{
|
|
37
33
|
id: zod.ZodString;
|
|
38
|
-
},
|
|
39
|
-
id: string;
|
|
40
|
-
}, {
|
|
41
|
-
id: string;
|
|
42
|
-
}>, "many">, Partial<Record<RelationsOperation, {
|
|
34
|
+
}, zod.z.core.$strip>>, zod.ZodTransform<Partial<Record<RelationsOperation, {
|
|
43
35
|
id: string;
|
|
44
36
|
}[]>>, {
|
|
45
37
|
id: string;
|
|
46
|
-
}[]
|
|
47
|
-
disconnect: zod.
|
|
38
|
+
}[]>>;
|
|
39
|
+
disconnect: zod.ZodPipe<zod.ZodArray<zod.ZodObject<{
|
|
48
40
|
id: zod.ZodString;
|
|
49
|
-
},
|
|
50
|
-
id: string;
|
|
51
|
-
}, {
|
|
52
|
-
id: string;
|
|
53
|
-
}>, "many">, Partial<Record<RelationsOperation, {
|
|
41
|
+
}, zod.z.core.$strip>>, zod.ZodTransform<Partial<Record<RelationsOperation, {
|
|
54
42
|
id: string;
|
|
55
43
|
}[]>>, {
|
|
56
44
|
id: string;
|
|
57
|
-
}[]
|
|
58
|
-
delete: zod.
|
|
45
|
+
}[]>>;
|
|
46
|
+
delete: zod.ZodPipe<zod.ZodArray<zod.ZodObject<{
|
|
59
47
|
id: zod.ZodString;
|
|
60
|
-
},
|
|
61
|
-
id: string;
|
|
62
|
-
}, {
|
|
63
|
-
id: string;
|
|
64
|
-
}>, "many">, Partial<Record<RelationsOperation, {
|
|
48
|
+
}, zod.z.core.$strip>>, zod.ZodTransform<Partial<Record<RelationsOperation, {
|
|
65
49
|
id: string;
|
|
66
50
|
}[]>>, {
|
|
67
51
|
id: string;
|
|
68
|
-
}[]
|
|
69
|
-
connect: zod.
|
|
52
|
+
}[]>>;
|
|
53
|
+
connect: zod.ZodPipe<zod.ZodArray<zod.ZodObject<{
|
|
70
54
|
id: zod.ZodString;
|
|
71
|
-
},
|
|
72
|
-
id: string;
|
|
73
|
-
}, {
|
|
74
|
-
id: string;
|
|
75
|
-
}>, "many">, Partial<Record<RelationsOperation, {
|
|
55
|
+
}, zod.z.core.$strip>>, zod.ZodTransform<Partial<Record<RelationsOperation, {
|
|
76
56
|
id: string;
|
|
77
57
|
}[]>>, {
|
|
78
58
|
id: string;
|
|
79
|
-
}[]
|
|
80
|
-
create<T extends zod.ZodRawShape>(shap: T): zod.
|
|
81
|
-
create:
|
|
82
|
-
},
|
|
83
|
-
connectOrCreate<T extends zod.ZodRawShape>(shap: T): zod.
|
|
84
|
-
connectOrCreate:
|
|
85
|
-
},
|
|
86
|
-
upsert<T extends zod.ZodRawShape>(shap: T): zod.
|
|
87
|
-
upsert:
|
|
88
|
-
},
|
|
89
|
-
createMany<T extends zod.ZodRawShape>(shap: T): zod.
|
|
90
|
-
createMany:
|
|
91
|
-
},
|
|
92
|
-
update<T extends zod.ZodRawShape>(shap: T): zod.
|
|
93
|
-
update:
|
|
94
|
-
},
|
|
95
|
-
updateMany<T extends zod.ZodRawShape>(shap: T): zod.
|
|
96
|
-
updateMany:
|
|
97
|
-
},
|
|
98
|
-
deleteMany<T extends zod.ZodRawShape>(shap: T): zod.
|
|
99
|
-
deleteMany:
|
|
100
|
-
},
|
|
59
|
+
}[]>>;
|
|
60
|
+
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<{
|
|
61
|
+
create: zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[];
|
|
62
|
+
}, zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[]>>;
|
|
63
|
+
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<{
|
|
64
|
+
connectOrCreate: zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[];
|
|
65
|
+
}, zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[]>>;
|
|
66
|
+
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<{
|
|
67
|
+
upsert: zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[];
|
|
68
|
+
}, zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[]>>;
|
|
69
|
+
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<{
|
|
70
|
+
createMany: zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[];
|
|
71
|
+
}, zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[]>>;
|
|
72
|
+
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<{
|
|
73
|
+
update: zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[];
|
|
74
|
+
}, zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[]>>;
|
|
75
|
+
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<{
|
|
76
|
+
updateMany: zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[];
|
|
77
|
+
}, zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[]>>;
|
|
78
|
+
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<{
|
|
79
|
+
deleteMany: zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[];
|
|
80
|
+
}, zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}> | zod.z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>[]>>;
|
|
101
81
|
};
|
|
102
82
|
filter: {
|
|
103
|
-
number: zod.ZodOptional<zod.ZodUnion<[zod.ZodObject<{
|
|
83
|
+
number: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodObject<{
|
|
104
84
|
min: zod.ZodOptional<zod.ZodNumber>;
|
|
105
85
|
max: zod.ZodOptional<zod.ZodNumber>;
|
|
106
|
-
},
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
}, "
|
|
116
|
-
min?: number | undefined;
|
|
117
|
-
max?: number | undefined;
|
|
118
|
-
}, {
|
|
119
|
-
min?: number | undefined;
|
|
120
|
-
max?: number | undefined;
|
|
121
|
-
}>>]>>;
|
|
122
|
-
multiselect: zod.ZodOptional<zod.ZodUnion<[zod.ZodArray<zod.ZodString, "many">, zod.ZodPipeline<zod.ZodEffects<zod.ZodString, zod.RefinementCtx, string>, zod.ZodArray<zod.ZodString, "many">>]>>;
|
|
123
|
-
range: zod.ZodOptional<zod.ZodUnion<[zod.ZodObject<{
|
|
124
|
-
start: zod.ZodOptional<zod.ZodDate>;
|
|
125
|
-
end: zod.ZodOptional<zod.ZodDate>;
|
|
126
|
-
}, "strip", zod.ZodTypeAny, {
|
|
127
|
-
start?: Date | undefined;
|
|
128
|
-
end?: Date | undefined;
|
|
129
|
-
}, {
|
|
130
|
-
start?: Date | undefined;
|
|
131
|
-
end?: Date | undefined;
|
|
132
|
-
}>, zod.ZodPipeline<zod.ZodEffects<zod.ZodString, zod.RefinementCtx, string>, zod.ZodObject<{
|
|
133
|
-
start: zod.ZodOptional<zod.ZodDate>;
|
|
134
|
-
end: zod.ZodOptional<zod.ZodDate>;
|
|
135
|
-
}, "strip", zod.ZodTypeAny, {
|
|
136
|
-
start?: Date | undefined;
|
|
137
|
-
end?: Date | undefined;
|
|
138
|
-
}, {
|
|
139
|
-
start?: Date | undefined;
|
|
140
|
-
end?: Date | undefined;
|
|
141
|
-
}>>]>>;
|
|
142
|
-
boolean: zod.ZodOptional<zod.ZodEffects<zod.ZodEnum<["true", "false"]>, boolean, "true" | "false">>;
|
|
86
|
+
}, 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>>>>]>>;
|
|
87
|
+
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>>>>]>>;
|
|
88
|
+
range: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodObject<{
|
|
89
|
+
start: zod.ZodOptional<zod.z.ZodCoercedDate<unknown>>;
|
|
90
|
+
end: zod.ZodOptional<zod.z.ZodCoercedDate<unknown>>;
|
|
91
|
+
}, 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>>>>]>>;
|
|
92
|
+
boolean: zod.ZodOptional<zod.ZodPipe<zod.ZodEnum<{
|
|
93
|
+
true: "true";
|
|
94
|
+
false: "false";
|
|
95
|
+
}>, zod.ZodTransform<boolean, "true" | "false">>>;
|
|
143
96
|
};
|
|
144
97
|
z: typeof zod.z;
|
|
145
98
|
default: typeof zod.z;
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
objectUtil: typeof zod.objectUtil;
|
|
167
|
-
ZodParsedType: {
|
|
168
|
-
string: "string";
|
|
169
|
-
nan: "nan";
|
|
170
|
-
number: "number";
|
|
171
|
-
integer: "integer";
|
|
172
|
-
float: "float";
|
|
173
|
-
boolean: "boolean";
|
|
174
|
-
date: "date";
|
|
175
|
-
bigint: "bigint";
|
|
176
|
-
symbol: "symbol";
|
|
177
|
-
function: "function";
|
|
178
|
-
undefined: "undefined";
|
|
179
|
-
null: "null";
|
|
180
|
-
array: "array";
|
|
181
|
-
object: "object";
|
|
182
|
-
unknown: "unknown";
|
|
183
|
-
promise: "promise";
|
|
184
|
-
void: "void";
|
|
185
|
-
never: "never";
|
|
186
|
-
map: "map";
|
|
187
|
-
set: "set";
|
|
188
|
-
};
|
|
189
|
-
getParsedType: (data: any) => zod.ZodParsedType;
|
|
190
|
-
datetimeRegex(args: {
|
|
191
|
-
precision?: number | null;
|
|
192
|
-
offset?: boolean;
|
|
193
|
-
local?: boolean;
|
|
194
|
-
}): RegExp;
|
|
195
|
-
custom<T>(check?: (data: any) => any, _params?: string | (Partial<zod.util.Omit<zod.ZodCustomIssue, "code">> & {
|
|
196
|
-
fatal?: boolean;
|
|
197
|
-
}) | ((input: any) => Partial<zod.util.Omit<zod.ZodCustomIssue, "code">> & {
|
|
198
|
-
fatal?: boolean;
|
|
199
|
-
}), fatal?: boolean): zod.ZodType<T, zod.ZodTypeDef, T>;
|
|
200
|
-
ZodType: typeof zod.ZodType;
|
|
201
|
-
ZodString: typeof zod.ZodString;
|
|
202
|
-
ZodNumber: typeof zod.ZodNumber;
|
|
203
|
-
ZodBigInt: typeof zod.ZodBigInt;
|
|
204
|
-
ZodBoolean: typeof zod.ZodBoolean;
|
|
205
|
-
ZodDate: typeof zod.ZodDate;
|
|
206
|
-
ZodSymbol: typeof zod.ZodSymbol;
|
|
207
|
-
ZodUndefined: typeof zod.ZodUndefined;
|
|
208
|
-
ZodNull: typeof zod.ZodNull;
|
|
209
|
-
ZodAny: typeof zod.ZodAny;
|
|
210
|
-
ZodUnknown: typeof zod.ZodUnknown;
|
|
211
|
-
ZodNever: typeof zod.ZodNever;
|
|
212
|
-
ZodVoid: typeof zod.ZodVoid;
|
|
213
|
-
ZodArray: typeof zod.ZodArray;
|
|
214
|
-
ZodObject: typeof zod.ZodObject;
|
|
215
|
-
ZodUnion: typeof zod.ZodUnion;
|
|
216
|
-
ZodDiscriminatedUnion: typeof zod.ZodDiscriminatedUnion;
|
|
217
|
-
ZodIntersection: typeof zod.ZodIntersection;
|
|
218
|
-
ZodTuple: typeof zod.ZodTuple;
|
|
219
|
-
ZodRecord: typeof zod.ZodRecord;
|
|
220
|
-
ZodMap: typeof zod.ZodMap;
|
|
221
|
-
ZodSet: typeof zod.ZodSet;
|
|
222
|
-
ZodFunction: typeof zod.ZodFunction;
|
|
223
|
-
ZodLazy: typeof zod.ZodLazy;
|
|
224
|
-
ZodLiteral: typeof zod.ZodLiteral;
|
|
225
|
-
ZodEnum: typeof zod.ZodEnum;
|
|
226
|
-
ZodNativeEnum: typeof zod.ZodNativeEnum;
|
|
227
|
-
ZodPromise: typeof zod.ZodPromise;
|
|
228
|
-
ZodEffects: typeof zod.ZodEffects;
|
|
229
|
-
ZodTransformer: typeof zod.ZodEffects;
|
|
230
|
-
ZodOptional: typeof zod.ZodOptional;
|
|
231
|
-
ZodNullable: typeof zod.ZodNullable;
|
|
232
|
-
ZodDefault: typeof zod.ZodDefault;
|
|
233
|
-
ZodCatch: typeof zod.ZodCatch;
|
|
234
|
-
ZodNaN: typeof zod.ZodNaN;
|
|
235
|
-
BRAND: typeof zod.BRAND;
|
|
236
|
-
ZodBranded: typeof zod.ZodBranded;
|
|
237
|
-
ZodPipeline: typeof zod.ZodPipeline;
|
|
238
|
-
ZodReadonly: typeof zod.ZodReadonly;
|
|
239
|
-
Schema: typeof zod.ZodType;
|
|
240
|
-
ZodSchema: typeof zod.ZodType;
|
|
241
|
-
late: {
|
|
242
|
-
object: <Shape extends zod.ZodRawShape>(shape: () => Shape, params?: zod.RawCreateParams) => zod.ZodObject<Shape, "strip">;
|
|
243
|
-
};
|
|
244
|
-
ZodFirstPartyTypeKind: typeof zod.ZodFirstPartyTypeKind;
|
|
245
|
-
coerce: {
|
|
246
|
-
string: (typeof zod.ZodString)["create"];
|
|
247
|
-
number: (typeof zod.ZodNumber)["create"];
|
|
248
|
-
boolean: (typeof zod.ZodBoolean)["create"];
|
|
249
|
-
bigint: (typeof zod.ZodBigInt)["create"];
|
|
250
|
-
date: (typeof zod.ZodDate)["create"];
|
|
251
|
-
};
|
|
252
|
-
any: (params?: zod.RawCreateParams) => zod.ZodAny;
|
|
253
|
-
array: <El extends zod.ZodTypeAny>(schema: El, params?: zod.RawCreateParams) => zod.ZodArray<El>;
|
|
254
|
-
bigint: (params?: zod.RawCreateParams & {
|
|
255
|
-
coerce?: boolean;
|
|
256
|
-
}) => zod.ZodBigInt;
|
|
257
|
-
boolean: (params?: zod.RawCreateParams & {
|
|
258
|
-
coerce?: boolean;
|
|
259
|
-
}) => zod.ZodBoolean;
|
|
260
|
-
date: (params?: zod.RawCreateParams & {
|
|
261
|
-
coerce?: boolean;
|
|
262
|
-
}) => zod.ZodDate;
|
|
263
|
-
discriminatedUnion: typeof zod.ZodDiscriminatedUnion.create;
|
|
264
|
-
effect: <I extends zod.ZodTypeAny>(schema: I, effect: zod.Effect<I["_output"]>, params?: zod.RawCreateParams) => zod.ZodEffects<I, I["_output"]>;
|
|
265
|
-
enum: {
|
|
266
|
-
<U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: zod.RawCreateParams): zod.ZodEnum<zod.Writeable<T>>;
|
|
267
|
-
<U extends string, T extends [U, ...U[]]>(values: T, params?: zod.RawCreateParams): zod.ZodEnum<T>;
|
|
99
|
+
core: typeof zod.z.core;
|
|
100
|
+
globalRegistry: zod.z.core.$ZodRegistry<zod.z.core.GlobalMeta, zod.z.core.$ZodType<unknown, unknown, zod.z.core.$ZodTypeInternals<unknown, unknown>>>;
|
|
101
|
+
registry: typeof zod.z.core.registry;
|
|
102
|
+
config: typeof zod.z.core.config;
|
|
103
|
+
$output: typeof zod.z.core.$output;
|
|
104
|
+
$input: typeof zod.z.core.$input;
|
|
105
|
+
$brand: typeof zod.z.core.$brand;
|
|
106
|
+
clone: typeof zod.z.core.util.clone;
|
|
107
|
+
regexes: typeof zod.z.core.regexes;
|
|
108
|
+
treeifyError: typeof zod.z.core.treeifyError;
|
|
109
|
+
prettifyError: typeof zod.z.core.prettifyError;
|
|
110
|
+
formatError: typeof zod.z.core.formatError;
|
|
111
|
+
flattenError: typeof zod.z.core.flattenError;
|
|
112
|
+
toJSONSchema: typeof zod.z.core.toJSONSchema;
|
|
113
|
+
TimePrecision: {
|
|
114
|
+
readonly Any: null;
|
|
115
|
+
readonly Minute: -1;
|
|
116
|
+
readonly Second: 0;
|
|
117
|
+
readonly Millisecond: 3;
|
|
118
|
+
readonly Microsecond: 6;
|
|
268
119
|
};
|
|
269
|
-
|
|
270
|
-
instanceof: <T extends abstract new (..._: any[]) => {}>(cls: T, params?: Partial<zod.util.Omit<zod.ZodCustomIssue, "code">> & {
|
|
271
|
-
fatal?: boolean;
|
|
272
|
-
}) => zod.ZodType<InstanceType<T>, zod.ZodTypeDef, InstanceType<T>>;
|
|
273
|
-
intersection: <TSchema extends zod.ZodTypeAny, USchema extends zod.ZodTypeAny>(left: TSchema, right: USchema, params?: zod.RawCreateParams) => zod.ZodIntersection<TSchema, USchema>;
|
|
274
|
-
lazy: <Inner extends zod.ZodTypeAny>(getter: () => Inner, params?: zod.RawCreateParams) => zod.ZodLazy<Inner>;
|
|
275
|
-
literal: <Value extends zod.Primitive>(value: Value, params?: zod.RawCreateParams) => zod.ZodLiteral<Value>;
|
|
276
|
-
map: <KeySchema extends zod.ZodTypeAny = zod.ZodTypeAny, ValueSchema extends zod.ZodTypeAny = zod.ZodTypeAny>(keyType: KeySchema, valueType: ValueSchema, params?: zod.RawCreateParams) => zod.ZodMap<KeySchema, ValueSchema>;
|
|
277
|
-
nan: (params?: zod.RawCreateParams) => zod.ZodNaN;
|
|
278
|
-
nativeEnum: <Elements extends zod.EnumLike>(values: Elements, params?: zod.RawCreateParams) => zod.ZodNativeEnum<Elements>;
|
|
279
|
-
never: (params?: zod.RawCreateParams) => zod.ZodNever;
|
|
280
|
-
null: (params?: zod.RawCreateParams) => zod.ZodNull;
|
|
281
|
-
nullable: <Inner extends zod.ZodTypeAny>(type: Inner, params?: zod.RawCreateParams) => zod.ZodNullable<Inner>;
|
|
282
|
-
number: (params?: zod.RawCreateParams & {
|
|
283
|
-
coerce?: boolean;
|
|
284
|
-
}) => zod.ZodNumber;
|
|
285
|
-
object: <Shape extends zod.ZodRawShape>(shape: Shape, params?: zod.RawCreateParams) => zod.ZodObject<Shape, "strip", zod.ZodTypeAny, zod.objectOutputType<Shape, zod.ZodTypeAny, "strip">, zod.objectInputType<Shape, zod.ZodTypeAny, "strip">>;
|
|
286
|
-
oboolean: () => zod.ZodOptional<zod.ZodBoolean>;
|
|
287
|
-
onumber: () => zod.ZodOptional<zod.ZodNumber>;
|
|
288
|
-
optional: <Inner extends zod.ZodTypeAny>(type: Inner, params?: zod.RawCreateParams) => zod.ZodOptional<Inner>;
|
|
289
|
-
ostring: () => zod.ZodOptional<zod.ZodString>;
|
|
290
|
-
pipeline: typeof zod.ZodPipeline.create;
|
|
291
|
-
preprocess: <I extends zod.ZodTypeAny>(preprocess: (arg: unknown, ctx: zod.RefinementCtx) => unknown, schema: I, params?: zod.RawCreateParams) => zod.ZodEffects<I, I["_output"], unknown>;
|
|
292
|
-
promise: <Inner extends zod.ZodTypeAny>(schema: Inner, params?: zod.RawCreateParams) => zod.ZodPromise<Inner>;
|
|
293
|
-
record: typeof zod.ZodRecord.create;
|
|
294
|
-
set: <ValueSchema extends zod.ZodTypeAny = zod.ZodTypeAny>(valueType: ValueSchema, params?: zod.RawCreateParams) => zod.ZodSet<ValueSchema>;
|
|
295
|
-
strictObject: <Shape extends zod.ZodRawShape>(shape: Shape, params?: zod.RawCreateParams) => zod.ZodObject<Shape, "strict">;
|
|
296
|
-
string: (params?: zod.RawCreateParams & {
|
|
297
|
-
coerce?: true;
|
|
298
|
-
}) => zod.ZodString;
|
|
299
|
-
symbol: (params?: zod.RawCreateParams) => zod.ZodSymbol;
|
|
300
|
-
transformer: <I extends zod.ZodTypeAny>(schema: I, effect: zod.Effect<I["_output"]>, params?: zod.RawCreateParams) => zod.ZodEffects<I, I["_output"]>;
|
|
301
|
-
tuple: <Items extends [zod.ZodTypeAny, ...zod.ZodTypeAny[]] | []>(schemas: Items, params?: zod.RawCreateParams) => zod.ZodTuple<Items, null>;
|
|
302
|
-
undefined: (params?: zod.RawCreateParams) => zod.ZodUndefined;
|
|
303
|
-
union: <Options extends Readonly<[zod.ZodTypeAny, zod.ZodTypeAny, ...zod.ZodTypeAny[]]>>(types: Options, params?: zod.RawCreateParams) => zod.ZodUnion<Options>;
|
|
304
|
-
unknown: (params?: zod.RawCreateParams) => zod.ZodUnknown;
|
|
305
|
-
void: (params?: zod.RawCreateParams) => zod.ZodVoid;
|
|
120
|
+
util: typeof zod.z.core.util;
|
|
306
121
|
NEVER: never;
|
|
122
|
+
locales: typeof zod.z.core.locales;
|
|
123
|
+
ZodISODateTime: zod.z.core.$constructor<zod.z.ZodISODateTime, zod.z.core.$ZodISODateTimeDef>;
|
|
124
|
+
ZodISODate: zod.z.core.$constructor<zod.z.ZodISODate, zod.z.core.$ZodStringFormatDef<"date">>;
|
|
125
|
+
ZodISOTime: zod.z.core.$constructor<zod.z.ZodISOTime, zod.z.core.$ZodISOTimeDef>;
|
|
126
|
+
ZodISODuration: zod.z.core.$constructor<zod.z.ZodISODuration, zod.z.core.$ZodStringFormatDef<"duration">>;
|
|
127
|
+
iso: typeof zod.z.iso;
|
|
128
|
+
coerce: typeof zod.z.coerce;
|
|
129
|
+
string(params?: string | zod.z.core.$ZodStringParams): zod.ZodString;
|
|
130
|
+
string<T extends string>(params?: string | zod.z.core.$ZodStringParams): zod.z.core.$ZodType<T, T>;
|
|
131
|
+
email(params?: string | zod.z.core.$ZodEmailParams): zod.ZodEmail;
|
|
132
|
+
guid(params?: string | zod.z.core.$ZodGUIDParams): zod.ZodGUID;
|
|
133
|
+
uuid(params?: string | zod.z.core.$ZodUUIDParams): zod.ZodUUID;
|
|
134
|
+
uuidv4(params?: string | zod.z.core.$ZodUUIDv4Params): zod.ZodUUID;
|
|
135
|
+
uuidv6(params?: string | zod.z.core.$ZodUUIDv6Params): zod.ZodUUID;
|
|
136
|
+
uuidv7(params?: string | zod.z.core.$ZodUUIDv7Params): zod.ZodUUID;
|
|
137
|
+
url(params?: string | zod.z.core.$ZodURLParams): zod.ZodURL;
|
|
138
|
+
httpUrl(params?: string | Omit<zod.z.core.$ZodURLParams, "protocol" | "hostname">): zod.ZodURL;
|
|
139
|
+
emoji(params?: string | zod.z.core.$ZodEmojiParams): zod.ZodEmoji;
|
|
140
|
+
nanoid(params?: string | zod.z.core.$ZodNanoIDParams): zod.ZodNanoID;
|
|
141
|
+
cuid(params?: string | zod.z.core.$ZodCUIDParams): zod.ZodCUID;
|
|
142
|
+
cuid2(params?: string | zod.z.core.$ZodCUID2Params): zod.ZodCUID2;
|
|
143
|
+
ulid(params?: string | zod.z.core.$ZodULIDParams): zod.ZodULID;
|
|
144
|
+
xid(params?: string | zod.z.core.$ZodXIDParams): zod.ZodXID;
|
|
145
|
+
ksuid(params?: string | zod.z.core.$ZodKSUIDParams): zod.ZodKSUID;
|
|
146
|
+
ipv4(params?: string | zod.z.core.$ZodIPv4Params): zod.ZodIPv4;
|
|
147
|
+
ipv6(params?: string | zod.z.core.$ZodIPv6Params): zod.ZodIPv6;
|
|
148
|
+
cidrv4(params?: string | zod.z.core.$ZodCIDRv4Params): zod.ZodCIDRv4;
|
|
149
|
+
cidrv6(params?: string | zod.z.core.$ZodCIDRv6Params): zod.ZodCIDRv6;
|
|
150
|
+
base64(params?: string | zod.z.core.$ZodBase64Params): zod.ZodBase64;
|
|
151
|
+
base64url(params?: string | zod.z.core.$ZodBase64URLParams): zod.ZodBase64URL;
|
|
152
|
+
e164(params?: string | zod.z.core.$ZodE164Params): zod.ZodE164;
|
|
153
|
+
jwt(params?: string | zod.z.core.$ZodJWTParams): zod.ZodJWT;
|
|
154
|
+
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>;
|
|
155
|
+
hostname(_params?: string | zod.z.core.$ZodStringFormatParams): zod.ZodCustomStringFormat<"hostname">;
|
|
156
|
+
hex(_params?: string | zod.z.core.$ZodStringFormatParams): zod.ZodCustomStringFormat<"hex">;
|
|
157
|
+
hash<Alg extends zod.z.core.util.HashAlgorithm, Enc extends zod.z.core.util.HashEncoding = "hex">(alg: Alg, params?: {
|
|
158
|
+
enc?: Enc;
|
|
159
|
+
} & zod.z.core.$ZodStringFormatParams): zod.ZodCustomStringFormat<`${Alg}_${Enc}`>;
|
|
160
|
+
number(params?: string | zod.z.core.$ZodNumberParams): zod.ZodNumber;
|
|
161
|
+
int(params?: string | zod.z.core.$ZodCheckNumberFormatParams): zod.ZodInt;
|
|
162
|
+
float32(params?: string | zod.z.core.$ZodCheckNumberFormatParams): zod.ZodFloat32;
|
|
163
|
+
float64(params?: string | zod.z.core.$ZodCheckNumberFormatParams): zod.ZodFloat64;
|
|
164
|
+
int32(params?: string | zod.z.core.$ZodCheckNumberFormatParams): zod.ZodInt32;
|
|
165
|
+
uint32(params?: string | zod.z.core.$ZodCheckNumberFormatParams): zod.ZodUInt32;
|
|
166
|
+
boolean(params?: string | zod.z.core.$ZodBooleanParams): zod.ZodBoolean;
|
|
167
|
+
bigint(params?: string | zod.z.core.$ZodBigIntParams): zod.ZodBigInt;
|
|
168
|
+
int64(params?: string | zod.z.core.$ZodBigIntFormatParams): zod.ZodBigIntFormat;
|
|
169
|
+
uint64(params?: string | zod.z.core.$ZodBigIntFormatParams): zod.ZodBigIntFormat;
|
|
170
|
+
symbol(params?: string | zod.z.core.$ZodSymbolParams): zod.ZodSymbol;
|
|
171
|
+
any(): zod.ZodAny;
|
|
172
|
+
unknown(): zod.ZodUnknown;
|
|
173
|
+
never(params?: string | zod.z.core.$ZodNeverParams): zod.ZodNever;
|
|
174
|
+
date(params?: string | zod.z.core.$ZodDateParams): zod.ZodDate;
|
|
175
|
+
array<T extends zod.z.core.SomeType>(element: T, params?: string | zod.z.core.$ZodArrayParams): zod.ZodArray<T>;
|
|
176
|
+
keyof<T extends zod.ZodObject>(schema: T): zod.ZodEnum<zod.z.core.util.KeysEnum<T["_zod"]["output"]>>;
|
|
177
|
+
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>;
|
|
178
|
+
strictObject<T extends zod.z.core.$ZodLooseShape>(shape: T, params?: string | zod.z.core.$ZodObjectParams): zod.ZodObject<T, zod.z.core.$strict>;
|
|
179
|
+
looseObject<T extends zod.z.core.$ZodLooseShape>(shape: T, params?: string | zod.z.core.$ZodObjectParams): zod.ZodObject<T, zod.z.core.$loose>;
|
|
180
|
+
union<const T extends readonly zod.z.core.SomeType[]>(options: T, params?: string | zod.z.core.$ZodUnionParams): zod.ZodUnion<T>;
|
|
181
|
+
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>;
|
|
182
|
+
intersection<T extends zod.z.core.SomeType, U extends zod.z.core.SomeType>(left: T, right: U): zod.ZodIntersection<T, U>;
|
|
183
|
+
tuple<T extends readonly [zod.z.core.SomeType, ...zod.z.core.SomeType[]]>(items: T, params?: string | zod.z.core.$ZodTupleParams): zod.ZodTuple<T, null>;
|
|
184
|
+
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>;
|
|
185
|
+
tuple(items: [], params?: string | zod.z.core.$ZodTupleParams): zod.ZodTuple<[], null>;
|
|
186
|
+
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>;
|
|
187
|
+
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>;
|
|
188
|
+
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>;
|
|
189
|
+
set<Value extends zod.z.core.SomeType>(valueType: Value, params?: string | zod.z.core.$ZodSetParams): zod.ZodSet<Value>;
|
|
190
|
+
nativeEnum<T extends zod.z.core.util.EnumLike>(entries: T, params?: string | zod.z.core.$ZodEnumParams): zod.ZodEnum<T>;
|
|
191
|
+
literal<const T extends ReadonlyArray<zod.z.core.util.Literal>>(value: T, params?: string | zod.z.core.$ZodLiteralParams): zod.ZodLiteral<T[number]>;
|
|
192
|
+
literal<const T extends zod.z.core.util.Literal>(value: T, params?: string | zod.z.core.$ZodLiteralParams): zod.ZodLiteral<T>;
|
|
193
|
+
file(params?: string | zod.z.core.$ZodFileParams): zod.ZodFile;
|
|
194
|
+
transform<I = unknown, O = I>(fn: (input: I, ctx: zod.z.core.ParsePayload) => O): zod.ZodTransform<Awaited<O>, I>;
|
|
195
|
+
optional<T extends zod.z.core.SomeType>(innerType: T): zod.ZodOptional<T>;
|
|
196
|
+
nullable<T extends zod.z.core.SomeType>(innerType: T): zod.ZodNullable<T>;
|
|
197
|
+
nullish<T extends zod.z.core.SomeType>(innerType: T): zod.ZodOptional<zod.ZodNullable<T>>;
|
|
198
|
+
_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>;
|
|
199
|
+
prefault<T extends zod.z.core.SomeType>(innerType: T, defaultValue: zod.z.core.input<T> | (() => zod.z.core.input<T>)): zod.ZodPrefault<T>;
|
|
200
|
+
nonoptional<T extends zod.z.core.SomeType>(innerType: T, params?: string | zod.z.core.$ZodNonOptionalParams): zod.ZodNonOptional<T>;
|
|
201
|
+
success<T extends zod.z.core.SomeType>(innerType: T): zod.ZodSuccess<T>;
|
|
202
|
+
nan(params?: string | zod.z.core.$ZodNaNParams): zod.ZodNaN;
|
|
203
|
+
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>;
|
|
204
|
+
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: {
|
|
205
|
+
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>>;
|
|
206
|
+
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>>;
|
|
207
|
+
}): zod.ZodCodec<A, B>;
|
|
208
|
+
readonly<T extends zod.z.core.SomeType>(innerType: T): zod.ZodReadonly<T>;
|
|
209
|
+
templateLiteral<const Parts extends zod.z.core.$ZodTemplateLiteralPart[]>(parts: Parts, params?: string | zod.z.core.$ZodTemplateLiteralParams): zod.ZodTemplateLiteral<zod.z.core.$PartsToTemplateLiteral<Parts>>;
|
|
210
|
+
lazy<T extends zod.z.core.SomeType>(getter: () => T): zod.ZodLazy<T>;
|
|
211
|
+
promise<T extends zod.z.core.SomeType>(innerType: T): zod.ZodPromise<T>;
|
|
212
|
+
_function(): zod.ZodFunction;
|
|
213
|
+
_function<const In extends ReadonlyArray<zod.z.core.$ZodType>>(params: {
|
|
214
|
+
input: In;
|
|
215
|
+
}): zod.ZodFunction<zod.ZodTuple<In, null>, zod.z.core.$ZodFunctionOut>;
|
|
216
|
+
_function<const In extends ReadonlyArray<zod.z.core.$ZodType>, const Out extends zod.z.core.$ZodFunctionOut = zod.z.core.$ZodFunctionOut>(params: {
|
|
217
|
+
input: In;
|
|
218
|
+
output: Out;
|
|
219
|
+
}): zod.ZodFunction<zod.ZodTuple<In, null>, Out>;
|
|
220
|
+
_function<const In extends zod.z.core.$ZodFunctionIn = zod.z.core.$ZodFunctionArgs>(params: {
|
|
221
|
+
input: In;
|
|
222
|
+
}): zod.ZodFunction<In, zod.z.core.$ZodFunctionOut>;
|
|
223
|
+
_function<const Out extends zod.z.core.$ZodFunctionOut = zod.z.core.$ZodFunctionOut>(params: {
|
|
224
|
+
output: Out;
|
|
225
|
+
}): zod.ZodFunction<zod.z.core.$ZodFunctionIn, Out>;
|
|
226
|
+
_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?: {
|
|
227
|
+
input: In;
|
|
228
|
+
output: Out;
|
|
229
|
+
}): zod.ZodFunction<In, Out>;
|
|
230
|
+
check<O = unknown>(fn: zod.z.core.CheckFn<O>): zod.z.core.$ZodCheck<O>;
|
|
231
|
+
custom<O>(fn?: (data: unknown) => unknown, _params?: string | zod.z.core.$ZodCustomParams | undefined): zod.ZodCustom<O, O>;
|
|
232
|
+
refine<T>(fn: (arg: NoInfer<T>) => zod.z.core.util.MaybeAsync<unknown>, _params?: string | zod.z.core.$ZodCustomParams): zod.z.core.$ZodCheck<T>;
|
|
233
|
+
superRefine<T>(fn: (arg: T, payload: zod.z.core.$RefinementCtx<T>) => void | Promise<void>): zod.z.core.$ZodCheck<T>;
|
|
234
|
+
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>;
|
|
235
|
+
ZodType: zod.z.core.$constructor<zod.ZodType>;
|
|
236
|
+
_ZodString: zod.z.core.$constructor<zod._ZodString>;
|
|
237
|
+
ZodString: zod.z.core.$constructor<zod.ZodString>;
|
|
238
|
+
ZodStringFormat: zod.z.core.$constructor<zod.ZodStringFormat>;
|
|
239
|
+
ZodEmail: zod.z.core.$constructor<zod.ZodEmail>;
|
|
240
|
+
ZodGUID: zod.z.core.$constructor<zod.ZodGUID>;
|
|
241
|
+
ZodUUID: zod.z.core.$constructor<zod.ZodUUID>;
|
|
242
|
+
ZodURL: zod.z.core.$constructor<zod.ZodURL>;
|
|
243
|
+
ZodEmoji: zod.z.core.$constructor<zod.ZodEmoji>;
|
|
244
|
+
ZodNanoID: zod.z.core.$constructor<zod.ZodNanoID>;
|
|
245
|
+
ZodCUID: zod.z.core.$constructor<zod.ZodCUID>;
|
|
246
|
+
ZodCUID2: zod.z.core.$constructor<zod.ZodCUID2>;
|
|
247
|
+
ZodULID: zod.z.core.$constructor<zod.ZodULID>;
|
|
248
|
+
ZodXID: zod.z.core.$constructor<zod.ZodXID>;
|
|
249
|
+
ZodKSUID: zod.z.core.$constructor<zod.ZodKSUID>;
|
|
250
|
+
ZodIPv4: zod.z.core.$constructor<zod.ZodIPv4>;
|
|
251
|
+
ZodIPv6: zod.z.core.$constructor<zod.ZodIPv6>;
|
|
252
|
+
ZodCIDRv4: zod.z.core.$constructor<zod.ZodCIDRv4>;
|
|
253
|
+
ZodCIDRv6: zod.z.core.$constructor<zod.ZodCIDRv6>;
|
|
254
|
+
ZodBase64: zod.z.core.$constructor<zod.ZodBase64>;
|
|
255
|
+
ZodBase64URL: zod.z.core.$constructor<zod.ZodBase64URL>;
|
|
256
|
+
ZodE164: zod.z.core.$constructor<zod.ZodE164>;
|
|
257
|
+
ZodJWT: zod.z.core.$constructor<zod.ZodJWT>;
|
|
258
|
+
ZodCustomStringFormat: zod.z.core.$constructor<zod.ZodCustomStringFormat>;
|
|
259
|
+
ZodNumber: zod.z.core.$constructor<zod.ZodNumber>;
|
|
260
|
+
ZodNumberFormat: zod.z.core.$constructor<zod.ZodNumberFormat>;
|
|
261
|
+
ZodBoolean: zod.z.core.$constructor<zod.ZodBoolean>;
|
|
262
|
+
ZodBigInt: zod.z.core.$constructor<zod.ZodBigInt>;
|
|
263
|
+
ZodBigIntFormat: zod.z.core.$constructor<zod.ZodBigIntFormat>;
|
|
264
|
+
ZodSymbol: zod.z.core.$constructor<zod.ZodSymbol>;
|
|
265
|
+
ZodUndefined: zod.z.core.$constructor<zod.ZodUndefined>;
|
|
266
|
+
undefined: typeof zod.z.undefined;
|
|
267
|
+
ZodNull: zod.z.core.$constructor<zod.ZodNull>;
|
|
268
|
+
null: typeof zod.z.null;
|
|
269
|
+
ZodAny: zod.z.core.$constructor<zod.ZodAny>;
|
|
270
|
+
ZodUnknown: zod.z.core.$constructor<zod.ZodUnknown>;
|
|
271
|
+
ZodNever: zod.z.core.$constructor<zod.ZodNever>;
|
|
272
|
+
ZodVoid: zod.z.core.$constructor<zod.ZodVoid>;
|
|
273
|
+
void: typeof zod.z.void;
|
|
274
|
+
ZodDate: zod.z.core.$constructor<zod.ZodDate>;
|
|
275
|
+
ZodArray: zod.z.core.$constructor<zod.ZodArray>;
|
|
276
|
+
ZodObject: zod.z.core.$constructor<zod.ZodObject>;
|
|
277
|
+
ZodUnion: zod.z.core.$constructor<zod.ZodUnion>;
|
|
278
|
+
ZodDiscriminatedUnion: zod.z.core.$constructor<zod.ZodDiscriminatedUnion>;
|
|
279
|
+
ZodIntersection: zod.z.core.$constructor<zod.ZodIntersection>;
|
|
280
|
+
ZodTuple: zod.z.core.$constructor<zod.ZodTuple>;
|
|
281
|
+
ZodRecord: zod.z.core.$constructor<zod.ZodRecord>;
|
|
282
|
+
ZodMap: zod.z.core.$constructor<zod.ZodMap>;
|
|
283
|
+
ZodSet: zod.z.core.$constructor<zod.ZodSet>;
|
|
284
|
+
ZodEnum: zod.z.core.$constructor<zod.ZodEnum>;
|
|
285
|
+
enum: typeof zod.z.enum;
|
|
286
|
+
ZodLiteral: zod.z.core.$constructor<zod.ZodLiteral>;
|
|
287
|
+
ZodFile: zod.z.core.$constructor<zod.ZodFile>;
|
|
288
|
+
ZodTransform: zod.z.core.$constructor<zod.ZodTransform>;
|
|
289
|
+
ZodOptional: zod.z.core.$constructor<zod.ZodOptional>;
|
|
290
|
+
ZodNullable: zod.z.core.$constructor<zod.ZodNullable>;
|
|
291
|
+
ZodDefault: zod.z.core.$constructor<zod.ZodDefault>;
|
|
292
|
+
ZodPrefault: zod.z.core.$constructor<zod.ZodPrefault>;
|
|
293
|
+
ZodNonOptional: zod.z.core.$constructor<zod.ZodNonOptional>;
|
|
294
|
+
ZodSuccess: zod.z.core.$constructor<zod.ZodSuccess>;
|
|
295
|
+
ZodCatch: zod.z.core.$constructor<zod.ZodCatch>;
|
|
296
|
+
catch: typeof zod.z.catch;
|
|
297
|
+
ZodNaN: zod.z.core.$constructor<zod.ZodNaN>;
|
|
298
|
+
ZodPipe: zod.z.core.$constructor<zod.ZodPipe>;
|
|
299
|
+
ZodCodec: zod.z.core.$constructor<zod.ZodCodec>;
|
|
300
|
+
ZodReadonly: zod.z.core.$constructor<zod.ZodReadonly>;
|
|
301
|
+
ZodTemplateLiteral: zod.z.core.$constructor<zod.ZodTemplateLiteral>;
|
|
302
|
+
ZodLazy: zod.z.core.$constructor<zod.ZodLazy>;
|
|
303
|
+
ZodPromise: zod.z.core.$constructor<zod.ZodPromise>;
|
|
304
|
+
ZodFunction: zod.z.core.$constructor<zod.ZodFunction>;
|
|
305
|
+
function: typeof zod._function;
|
|
306
|
+
ZodCustom: zod.z.core.$constructor<zod.ZodCustom>;
|
|
307
|
+
instanceof: typeof zod.z.instanceof;
|
|
308
|
+
stringbool: (_params?: string | zod.z.core.$ZodStringBoolParams) => zod.ZodCodec<zod.ZodString, zod.ZodBoolean>;
|
|
309
|
+
lt: typeof zod.z.core._lt;
|
|
310
|
+
lte: typeof zod.z.core._lte;
|
|
311
|
+
gt: typeof zod.z.core._gt;
|
|
312
|
+
gte: typeof zod.z.core._gte;
|
|
313
|
+
positive: typeof zod.z.core._positive;
|
|
314
|
+
negative: typeof zod.z.core._negative;
|
|
315
|
+
nonpositive: typeof zod.z.core._nonpositive;
|
|
316
|
+
nonnegative: typeof zod.z.core._nonnegative;
|
|
317
|
+
multipleOf: typeof zod.z.core._multipleOf;
|
|
318
|
+
maxSize: typeof zod.z.core._maxSize;
|
|
319
|
+
minSize: typeof zod.z.core._minSize;
|
|
320
|
+
size: typeof zod.z.core._size;
|
|
321
|
+
maxLength: typeof zod.z.core._maxLength;
|
|
322
|
+
minLength: typeof zod.z.core._minLength;
|
|
323
|
+
length: typeof zod.z.core._length;
|
|
324
|
+
regex: typeof zod.z.core._regex;
|
|
325
|
+
lowercase: typeof zod.z.core._lowercase;
|
|
326
|
+
uppercase: typeof zod.z.core._uppercase;
|
|
327
|
+
includes: typeof zod.z.core._includes;
|
|
328
|
+
startsWith: typeof zod.z.core._startsWith;
|
|
329
|
+
endsWith: typeof zod.z.core._endsWith;
|
|
330
|
+
property: typeof zod.z.core._property;
|
|
331
|
+
mime: typeof zod.z.core._mime;
|
|
332
|
+
overwrite: typeof zod.z.core._overwrite;
|
|
333
|
+
normalize: typeof zod.z.core._normalize;
|
|
334
|
+
trim: typeof zod.z.core._trim;
|
|
335
|
+
toLowerCase: typeof zod.z.core._toLowerCase;
|
|
336
|
+
toUpperCase: typeof zod.z.core._toUpperCase;
|
|
337
|
+
ZodError: zod.z.core.$constructor<zod.ZodError>;
|
|
338
|
+
ZodRealError: zod.z.core.$constructor<zod.ZodError>;
|
|
339
|
+
parse: <T extends zod.z.core.$ZodType>(schema: T, value: unknown, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>, _params?: {
|
|
340
|
+
callee?: zod.z.core.util.AnyFunc;
|
|
341
|
+
Err?: zod.z.core.$ZodErrorClass;
|
|
342
|
+
}) => zod.z.core.output<T>;
|
|
343
|
+
parseAsync: <T extends zod.z.core.$ZodType>(schema: T, value: unknown, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>, _params?: {
|
|
344
|
+
callee?: zod.z.core.util.AnyFunc;
|
|
345
|
+
Err?: zod.z.core.$ZodErrorClass;
|
|
346
|
+
}) => Promise<zod.z.core.output<T>>;
|
|
347
|
+
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>>;
|
|
348
|
+
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>>>;
|
|
349
|
+
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>;
|
|
350
|
+
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>;
|
|
351
|
+
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>>;
|
|
352
|
+
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>>;
|
|
353
|
+
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>>;
|
|
354
|
+
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>>;
|
|
355
|
+
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>>>;
|
|
356
|
+
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>>>;
|
|
357
|
+
setErrorMap(map: zod.z.core.$ZodErrorMap): void;
|
|
358
|
+
getErrorMap(): zod.z.core.$ZodErrorMap<zod.z.core.$ZodIssue> | undefined;
|
|
307
359
|
ZodIssueCode: {
|
|
308
|
-
invalid_type: "invalid_type";
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
|
|
318
|
-
|
|
319
|
-
too_small: "too_small";
|
|
320
|
-
too_big: "too_big";
|
|
321
|
-
invalid_intersection_types: "invalid_intersection_types";
|
|
322
|
-
not_multiple_of: "not_multiple_of";
|
|
323
|
-
not_finite: "not_finite";
|
|
360
|
+
readonly invalid_type: "invalid_type";
|
|
361
|
+
readonly too_big: "too_big";
|
|
362
|
+
readonly too_small: "too_small";
|
|
363
|
+
readonly invalid_format: "invalid_format";
|
|
364
|
+
readonly not_multiple_of: "not_multiple_of";
|
|
365
|
+
readonly unrecognized_keys: "unrecognized_keys";
|
|
366
|
+
readonly invalid_union: "invalid_union";
|
|
367
|
+
readonly invalid_key: "invalid_key";
|
|
368
|
+
readonly invalid_element: "invalid_element";
|
|
369
|
+
readonly invalid_value: "invalid_value";
|
|
370
|
+
readonly custom: "custom";
|
|
324
371
|
};
|
|
325
|
-
|
|
326
|
-
ZodError: typeof zod.ZodError;
|
|
372
|
+
ZodFirstPartyTypeKind: typeof zod.ZodFirstPartyTypeKind;
|
|
327
373
|
};
|
|
328
374
|
export type ZodInfer<T extends zod.ZodType<any, any, any>> = T['_output'];
|
|
329
375
|
export type SuperRefinement<T> = zod.SuperRefinement<T>;
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "fuma",
|
|
3
|
-
"version": "2.0.
|
|
3
|
+
"version": "2.0.2",
|
|
4
4
|
"description": "My fullstack material build with sveltekit, daisyui, zod, prisma, lucia",
|
|
5
5
|
"author": {
|
|
6
6
|
"name": "Jonas Voisard",
|
|
@@ -73,7 +73,7 @@
|
|
|
73
73
|
"postcss-load-config": "^5.1.0",
|
|
74
74
|
"prettier": "^3.6.2",
|
|
75
75
|
"prettier-plugin-svelte": "^3.4.0",
|
|
76
|
-
"prettier-plugin-tailwindcss": "^0.
|
|
76
|
+
"prettier-plugin-tailwindcss": "^0.6.14",
|
|
77
77
|
"prisma": "^5.22.0",
|
|
78
78
|
"publint": "^0.1.16",
|
|
79
79
|
"svelte-check": "^3.8.6",
|
|
@@ -115,7 +115,7 @@
|
|
|
115
115
|
"tippy.js": "^6.3.7",
|
|
116
116
|
"ts-node": "^10.9.2",
|
|
117
117
|
"vite": "^7.1.7",
|
|
118
|
-
"zod": "^
|
|
118
|
+
"zod": "^4.1.11"
|
|
119
119
|
},
|
|
120
120
|
"scripts": {
|
|
121
121
|
"dev": "vite dev --host",
|