cogsbox-shape 0.5.22 → 0.5.25

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.
Files changed (7) hide show
  1. package/README.md +86 -89
  2. package/dist/example/schema.d.ts +1419 -633
  3. package/dist/example/user.d.ts +1409 -905
  4. package/dist/example/user.js +41 -8
  5. package/dist/schema.d.ts +1716 -871
  6. package/dist/schema.js +187 -219
  7. package/package.json +1 -3
package/dist/example/schema.d.ts CHANGED
@@ -2,273 +2,399 @@ declare const schemas: {
2
2
  user: {
3
3
  _tableName: string;
4
4
  id: {
5
- sql: {
6
- type: "int";
7
- pk: true;
8
- };
9
- dbType: import("zod").ZodNumber;
10
- zodDbSchema: import("zod").ZodNumber;
11
- zodClientSchema: import("zod").ZodString;
12
- jsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
13
- $schema?: string | undefined;
14
- definitions?: {
15
- [key: string]: import("zod-to-json-schema").JsonSchema7Type;
16
- } | undefined;
17
- };
18
- defaultValue: number;
19
- client: <ClientType extends import("zod").ZodTypeAny, DefaultValue extends import("zod").TypeOf<ClientType>>(assert?: ClientType | ((tools: {
20
- zod: import("zod").ZodString;
21
- serverType?: never;
22
- }) => ClientType) | undefined, defaultValue?: DefaultValue | (DefaultValue extends Date ? {
23
- default: "CURRENT_TIMESTAMP";
24
- defaultValue: Date;
25
- } : never) | undefined) => {
5
+ config: {
26
6
  sql: {
27
7
  type: "int";
28
8
  pk: true;
29
9
  };
30
- zodDbSchema: import("zod").ZodNumber;
31
- zodClientSchema: ClientType;
32
- jsonSchema: any;
33
- defaultValue: DefaultValue | (DefaultValue extends Date ? {
34
- default: "CURRENT_TIMESTAMP";
35
- defaultValue: Date;
36
- } : never);
10
+ zodSqlSchema: import("zod").ZodNumber;
11
+ zodNewSchema: import("zod").ZodNumber;
12
+ initialValue: undefined;
13
+ zodClientSchema: import("zod").ZodNumber;
14
+ zodValidationSchema: import("zod").ZodNumber;
15
+ };
16
+ validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
17
+ sql: import("zod").ZodNumber;
18
+ initialState: import("zod").ZodNumber;
19
+ client: import("zod").ZodNumber;
20
+ }) => TValidationNext)) => {
21
+ config: {
22
+ sql: {
23
+ type: "int";
24
+ pk: true;
25
+ };
26
+ zodSqlSchema: import("zod").ZodNumber;
27
+ zodNewSchema: import("zod").ZodNumber;
28
+ initialValue: undefined;
29
+ zodClientSchema: import("zod").ZodNumber;
30
+ zodValidationSchema: TValidationNext;
31
+ };
37
32
  transform: (transforms: {
38
- toClient: (dbValue: number) => import("zod").TypeOf<ClientType>;
39
- toDb: (clientValue: import("zod").TypeOf<ClientType>) => number;
33
+ toClient: (dbValue: number) => number;
34
+ toDb: (clientValue: number) => number;
40
35
  }) => {
36
+ config: {
37
+ sql: {
38
+ type: "int";
39
+ pk: true;
40
+ };
41
+ zodSqlSchema: import("zod").ZodNumber;
42
+ zodNewSchema: import("zod").ZodNumber;
43
+ initialValue: undefined;
44
+ zodClientSchema: import("zod").ZodNumber;
45
+ zodValidationSchema: TValidationNext;
46
+ } & {
47
+ transforms: {
48
+ toClient: (dbValue: number) => number;
49
+ toDb: (clientValue: number) => number;
50
+ };
51
+ };
52
+ };
53
+ };
54
+ client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
55
+ sql: import("zod").ZodNumber;
56
+ initialState: import("zod").ZodNumber;
57
+ }) => TClientNext)) => {
58
+ config: {
41
59
  sql: {
42
60
  type: "int";
43
61
  pk: true;
44
62
  };
45
- zodDbSchema: import("zod").ZodNumber;
46
- zodClientSchema: ClientType;
47
- jsonSchema: any;
48
- defaultValue: DefaultValue;
49
- toClient: (dbValue: number) => import("zod").TypeOf<ClientType>;
50
- toDb: (clientValue: import("zod").TypeOf<ClientType>) => number;
51
- transforms: {
52
- toClient: string;
53
- toDb: string;
63
+ zodSqlSchema: import("zod").ZodNumber;
64
+ zodNewSchema: import("zod").ZodNumber;
65
+ initialValue: undefined;
66
+ zodClientSchema: TClientNext;
67
+ zodValidationSchema: TClientNext;
68
+ };
69
+ validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
70
+ sql: import("zod").ZodNumber;
71
+ initialState: import("zod").ZodNumber;
72
+ client: TClientNext;
73
+ }) => TValidationNext)) => {
74
+ config: {
75
+ sql: {
76
+ type: "int";
77
+ pk: true;
78
+ };
79
+ zodSqlSchema: import("zod").ZodNumber;
80
+ zodNewSchema: import("zod").ZodNumber;
81
+ initialValue: undefined;
82
+ zodClientSchema: TClientNext;
83
+ zodValidationSchema: TValidationNext;
84
+ };
85
+ transform: (transforms: {
86
+ toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
87
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
88
+ }) => {
89
+ config: {
90
+ sql: {
91
+ type: "int";
92
+ pk: true;
93
+ };
94
+ zodSqlSchema: import("zod").ZodNumber;
95
+ zodNewSchema: import("zod").ZodNumber;
96
+ initialValue: undefined;
97
+ zodClientSchema: TClientNext;
98
+ zodValidationSchema: TValidationNext;
99
+ } & {
100
+ transforms: {
101
+ toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
102
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
103
+ };
104
+ };
105
+ };
106
+ };
107
+ transform: (transforms: {
108
+ toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
109
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
110
+ }) => {
111
+ config: {
112
+ sql: {
113
+ type: "int";
114
+ pk: true;
115
+ };
116
+ zodSqlSchema: import("zod").ZodNumber;
117
+ zodNewSchema: import("zod").ZodNumber;
118
+ initialValue: undefined;
119
+ zodClientSchema: TClientNext;
120
+ zodValidationSchema: TClientNext;
121
+ } & {
122
+ transforms: {
123
+ toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
124
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
125
+ };
54
126
  };
55
127
  };
56
128
  };
57
- db: <ServerType extends import("zod").ZodTypeAny>(assert: ServerType | ((tools: {
58
- zod: import("zod").ZodNumber;
59
- }) => ServerType)) => {
60
- sql: {
61
- type: "int";
62
- pk: true;
129
+ transform: (transforms: {
130
+ toClient: (dbValue: number) => number;
131
+ toDb: (clientValue: number) => number;
132
+ }) => {
133
+ config: {
134
+ sql: {
135
+ type: "int";
136
+ pk: true;
137
+ };
138
+ zodSqlSchema: import("zod").ZodNumber;
139
+ zodNewSchema: import("zod").ZodNumber;
140
+ initialValue: undefined;
141
+ zodClientSchema: import("zod").ZodNumber;
142
+ zodValidationSchema: import("zod").ZodNumber;
143
+ } & {
144
+ transforms: {
145
+ toClient: (dbValue: number) => number;
146
+ toDb: (clientValue: number) => number;
147
+ };
63
148
  };
64
- dbType: ServerType;
65
- zodDbSchema: ServerType;
66
- zodClientSchema: import("zod").ZodString;
67
- jsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
68
- $schema?: string | undefined;
69
- definitions?: {
70
- [key: string]: import("zod-to-json-schema").JsonSchema7Type;
71
- } | undefined;
72
- };
73
- defaultValue: import("zod").TypeOf<ServerType>;
74
- client: <ClientType extends import("zod").ZodTypeAny, DefaultValue extends import("zod").TypeOf<ClientType>>(assert?: ClientType | ((tools: {
75
- zod: import("zod").ZodString;
76
- serverType?: ServerType;
77
- }) => ClientType) | undefined, defaultValue?: DefaultValue | (DefaultValue extends Date ? {
78
- default: "CURRENT_TIMESTAMP";
79
- defaultValue: Date;
80
- } : never) | undefined) => {
149
+ };
150
+ initialState: <TNewNext extends import("zod").ZodTypeAny, TDefaultNext>(schema: TNewNext | ((tools: {
151
+ sql: import("zod").ZodNumber;
152
+ }) => TNewNext), defaultValue: () => TDefaultNext) => {
153
+ config: {
81
154
  sql: {
82
155
  type: "int";
83
156
  pk: true;
84
157
  };
85
- zodDbSchema: import("zod").ZodNumber | ServerType;
86
- zodClientSchema: ClientType;
87
- jsonSchema: any;
88
- defaultValue: DefaultValue | (DefaultValue extends Date ? {
89
- default: "CURRENT_TIMESTAMP";
90
- defaultValue: Date;
91
- } : never);
158
+ zodSqlSchema: import("zod").ZodNumber;
159
+ zodNewSchema: TNewNext;
160
+ initialValue: TDefaultNext;
161
+ zodClientSchema: import("zod").ZodNumber;
162
+ zodValidationSchema: import("zod").ZodNumber;
163
+ };
164
+ validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
165
+ sql: import("zod").ZodNumber;
166
+ initialState: TNewNext;
167
+ client: import("zod").ZodNumber;
168
+ }) => TValidationNext)) => {
169
+ config: {
170
+ sql: {
171
+ type: "int";
172
+ pk: true;
173
+ };
174
+ zodSqlSchema: import("zod").ZodNumber;
175
+ zodNewSchema: TNewNext;
176
+ initialValue: TDefaultNext;
177
+ zodClientSchema: import("zod").ZodNumber;
178
+ zodValidationSchema: TValidationNext;
179
+ };
180
+ transform: (transforms: {
181
+ toClient: (dbValue: number) => number;
182
+ toDb: (clientValue: number) => number;
183
+ }) => {
184
+ config: {
185
+ sql: {
186
+ type: "int";
187
+ pk: true;
188
+ };
189
+ zodSqlSchema: import("zod").ZodNumber;
190
+ zodNewSchema: TNewNext;
191
+ initialValue: TDefaultNext;
192
+ zodClientSchema: import("zod").ZodNumber;
193
+ zodValidationSchema: TValidationNext;
194
+ } & {
195
+ transforms: {
196
+ toClient: (dbValue: number) => number;
197
+ toDb: (clientValue: number) => number;
198
+ };
199
+ };
200
+ };
201
+ };
202
+ client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
203
+ sql: import("zod").ZodNumber;
204
+ initialState: TNewNext;
205
+ }) => TClientNext)) => {
206
+ config: {
207
+ sql: {
208
+ type: "int";
209
+ pk: true;
210
+ };
211
+ zodSqlSchema: import("zod").ZodNumber;
212
+ zodNewSchema: TNewNext;
213
+ initialValue: TDefaultNext;
214
+ zodClientSchema: TClientNext;
215
+ zodValidationSchema: TClientNext;
216
+ };
217
+ validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
218
+ sql: import("zod").ZodNumber;
219
+ initialState: TNewNext;
220
+ client: TClientNext;
221
+ }) => TValidationNext)) => {
222
+ config: {
223
+ sql: {
224
+ type: "int";
225
+ pk: true;
226
+ };
227
+ zodSqlSchema: import("zod").ZodNumber;
228
+ zodNewSchema: TNewNext;
229
+ initialValue: TDefaultNext;
230
+ zodClientSchema: TClientNext;
231
+ zodValidationSchema: TValidationNext;
232
+ };
233
+ transform: (transforms: {
234
+ toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
235
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
236
+ }) => {
237
+ config: {
238
+ sql: {
239
+ type: "int";
240
+ pk: true;
241
+ };
242
+ zodSqlSchema: import("zod").ZodNumber;
243
+ zodNewSchema: TNewNext;
244
+ initialValue: TDefaultNext;
245
+ zodClientSchema: TClientNext;
246
+ zodValidationSchema: TValidationNext;
247
+ } & {
248
+ transforms: {
249
+ toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
250
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
251
+ };
252
+ };
253
+ };
254
+ };
92
255
  transform: (transforms: {
93
- toClient: (dbValue: number) => import("zod").TypeOf<ClientType>;
94
- toDb: (clientValue: import("zod").TypeOf<ClientType>) => number;
256
+ toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
257
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
95
258
  }) => {
259
+ config: {
260
+ sql: {
261
+ type: "int";
262
+ pk: true;
263
+ };
264
+ zodSqlSchema: import("zod").ZodNumber;
265
+ zodNewSchema: TNewNext;
266
+ initialValue: TDefaultNext;
267
+ zodClientSchema: TClientNext;
268
+ zodValidationSchema: TClientNext;
269
+ } & {
270
+ transforms: {
271
+ toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
272
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
273
+ };
274
+ };
275
+ };
276
+ };
277
+ transform: (transforms: {
278
+ toClient: (dbValue: number) => number;
279
+ toDb: (clientValue: number) => number;
280
+ }) => {
281
+ config: {
96
282
  sql: {
97
283
  type: "int";
98
284
  pk: true;
99
285
  };
100
- zodDbSchema: import("zod").ZodNumber | ServerType;
101
- zodClientSchema: ClientType;
102
- jsonSchema: any;
103
- defaultValue: DefaultValue;
104
- toClient: (dbValue: number) => import("zod").TypeOf<ClientType>;
105
- toDb: (clientValue: import("zod").TypeOf<ClientType>) => number;
286
+ zodSqlSchema: import("zod").ZodNumber;
287
+ zodNewSchema: TNewNext;
288
+ initialValue: TDefaultNext;
289
+ zodClientSchema: import("zod").ZodNumber;
290
+ zodValidationSchema: import("zod").ZodNumber;
291
+ } & {
106
292
  transforms: {
107
- toClient: string;
108
- toDb: string;
293
+ toClient: (dbValue: number) => number;
294
+ toDb: (clientValue: number) => number;
109
295
  };
110
296
  };
111
297
  };
112
298
  };
113
299
  };
114
300
  firstname: {
115
- sql: {
116
- type: "varchar";
117
- length: number;
118
- };
119
- dbType: import("zod").ZodString;
120
- zodDbSchema: import("zod").ZodString;
121
- zodClientSchema: import("zod").ZodString;
122
- jsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
123
- $schema?: string | undefined;
124
- definitions?: {
125
- [key: string]: import("zod-to-json-schema").JsonSchema7Type;
126
- } | undefined;
127
- };
128
- defaultValue: string;
129
- client: <ClientType extends import("zod").ZodTypeAny, DefaultValue extends import("zod").TypeOf<ClientType>>(assert?: ClientType | ((tools: {
130
- zod: import("zod").ZodString;
131
- serverType?: import("zod").ZodString;
132
- }) => ClientType) | undefined, defaultValue?: DefaultValue | (DefaultValue extends Date ? {
133
- default: "CURRENT_TIMESTAMP";
134
- defaultValue: Date;
135
- } : never) | undefined) => {
301
+ config: {
136
302
  sql: {
137
303
  type: "varchar";
138
304
  length: number;
139
305
  };
140
- zodDbSchema: import("zod").ZodString;
141
- zodClientSchema: ClientType;
142
- jsonSchema: any;
143
- defaultValue: DefaultValue | (DefaultValue extends Date ? {
144
- default: "CURRENT_TIMESTAMP";
145
- defaultValue: Date;
146
- } : never);
147
- transform: (transforms: {
148
- toClient: (dbValue: string) => import("zod").TypeOf<ClientType>;
149
- toDb: (clientValue: import("zod").TypeOf<ClientType>) => string;
150
- }) => {
306
+ zodSqlSchema: import("zod").ZodString;
307
+ zodNewSchema: import("zod").ZodString;
308
+ initialValue: undefined;
309
+ zodClientSchema: import("zod").ZodString;
310
+ zodValidationSchema: import("zod").ZodString;
311
+ };
312
+ transform: (transforms: {
313
+ toClient: (dbValue: string) => string;
314
+ toDb: (clientValue: string) => string;
315
+ }) => {
316
+ config: {
151
317
  sql: {
152
318
  type: "varchar";
153
319
  length: number;
154
320
  };
155
- zodDbSchema: import("zod").ZodString;
156
- zodClientSchema: ClientType;
157
- jsonSchema: any;
158
- defaultValue: DefaultValue;
159
- toClient: (dbValue: string) => import("zod").TypeOf<ClientType>;
160
- toDb: (clientValue: import("zod").TypeOf<ClientType>) => string;
321
+ zodSqlSchema: import("zod").ZodString;
322
+ zodNewSchema: import("zod").ZodString;
323
+ initialValue: undefined;
324
+ zodClientSchema: import("zod").ZodString;
325
+ zodValidationSchema: import("zod").ZodString;
326
+ } & {
161
327
  transforms: {
162
- toClient: string;
163
- toDb: string;
328
+ toClient: (dbValue: string) => string;
329
+ toDb: (clientValue: string) => string;
164
330
  };
165
331
  };
166
332
  };
167
333
  };
168
334
  surname: {
169
- sql: {
170
- type: "varchar";
171
- length: number;
172
- };
173
- dbType: import("zod").ZodString;
174
- zodDbSchema: import("zod").ZodString;
175
- zodClientSchema: import("zod").ZodString;
176
- jsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
177
- $schema?: string | undefined;
178
- definitions?: {
179
- [key: string]: import("zod-to-json-schema").JsonSchema7Type;
180
- } | undefined;
181
- };
182
- defaultValue: string;
183
- client: <ClientType extends import("zod").ZodTypeAny, DefaultValue extends import("zod").TypeOf<ClientType>>(assert?: ClientType | ((tools: {
184
- zod: import("zod").ZodString;
185
- serverType?: import("zod").ZodString;
186
- }) => ClientType) | undefined, defaultValue?: DefaultValue | (DefaultValue extends Date ? {
187
- default: "CURRENT_TIMESTAMP";
188
- defaultValue: Date;
189
- } : never) | undefined) => {
335
+ config: {
190
336
  sql: {
191
337
  type: "varchar";
192
338
  length: number;
193
339
  };
194
- zodDbSchema: import("zod").ZodString;
195
- zodClientSchema: ClientType;
196
- jsonSchema: any;
197
- defaultValue: DefaultValue | (DefaultValue extends Date ? {
198
- default: "CURRENT_TIMESTAMP";
199
- defaultValue: Date;
200
- } : never);
201
- transform: (transforms: {
202
- toClient: (dbValue: string) => import("zod").TypeOf<ClientType>;
203
- toDb: (clientValue: import("zod").TypeOf<ClientType>) => string;
204
- }) => {
340
+ zodSqlSchema: import("zod").ZodString;
341
+ zodNewSchema: import("zod").ZodString;
342
+ initialValue: undefined;
343
+ zodClientSchema: import("zod").ZodString;
344
+ zodValidationSchema: import("zod").ZodString;
345
+ };
346
+ transform: (transforms: {
347
+ toClient: (dbValue: string) => string;
348
+ toDb: (clientValue: string) => string;
349
+ }) => {
350
+ config: {
205
351
  sql: {
206
352
  type: "varchar";
207
353
  length: number;
208
354
  };
209
- zodDbSchema: import("zod").ZodString;
210
- zodClientSchema: ClientType;
211
- jsonSchema: any;
212
- defaultValue: DefaultValue;
213
- toClient: (dbValue: string) => import("zod").TypeOf<ClientType>;
214
- toDb: (clientValue: import("zod").TypeOf<ClientType>) => string;
355
+ zodSqlSchema: import("zod").ZodString;
356
+ zodNewSchema: import("zod").ZodString;
357
+ initialValue: undefined;
358
+ zodClientSchema: import("zod").ZodString;
359
+ zodValidationSchema: import("zod").ZodString;
360
+ } & {
215
361
  transforms: {
216
- toClient: string;
217
- toDb: string;
362
+ toClient: (dbValue: string) => string;
363
+ toDb: (clientValue: string) => string;
218
364
  };
219
365
  };
220
366
  };
221
367
  };
222
368
  email: {
223
- sql: {
224
- type: "varchar";
225
- length: number;
226
- };
227
- dbType: import("zod").ZodString;
228
- zodDbSchema: import("zod").ZodString;
229
- zodClientSchema: import("zod").ZodString;
230
- jsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
231
- $schema?: string | undefined;
232
- definitions?: {
233
- [key: string]: import("zod-to-json-schema").JsonSchema7Type;
234
- } | undefined;
235
- };
236
- defaultValue: string;
237
- client: <ClientType extends import("zod").ZodTypeAny, DefaultValue extends import("zod").TypeOf<ClientType>>(assert?: ClientType | ((tools: {
238
- zod: import("zod").ZodString;
239
- serverType?: import("zod").ZodString;
240
- }) => ClientType) | undefined, defaultValue?: DefaultValue | (DefaultValue extends Date ? {
241
- default: "CURRENT_TIMESTAMP";
242
- defaultValue: Date;
243
- } : never) | undefined) => {
369
+ config: {
244
370
  sql: {
245
371
  type: "varchar";
246
372
  length: number;
247
373
  };
248
- zodDbSchema: import("zod").ZodString;
249
- zodClientSchema: ClientType;
250
- jsonSchema: any;
251
- defaultValue: DefaultValue | (DefaultValue extends Date ? {
252
- default: "CURRENT_TIMESTAMP";
253
- defaultValue: Date;
254
- } : never);
255
- transform: (transforms: {
256
- toClient: (dbValue: string) => import("zod").TypeOf<ClientType>;
257
- toDb: (clientValue: import("zod").TypeOf<ClientType>) => string;
258
- }) => {
374
+ zodSqlSchema: import("zod").ZodString;
375
+ zodNewSchema: import("zod").ZodString;
376
+ initialValue: undefined;
377
+ zodClientSchema: import("zod").ZodString;
378
+ zodValidationSchema: import("zod").ZodString;
379
+ };
380
+ transform: (transforms: {
381
+ toClient: (dbValue: string) => string;
382
+ toDb: (clientValue: string) => string;
383
+ }) => {
384
+ config: {
259
385
  sql: {
260
386
  type: "varchar";
261
387
  length: number;
262
388
  };
263
- zodDbSchema: import("zod").ZodString;
264
- zodClientSchema: ClientType;
265
- jsonSchema: any;
266
- defaultValue: DefaultValue;
267
- toClient: (dbValue: string) => import("zod").TypeOf<ClientType>;
268
- toDb: (clientValue: import("zod").TypeOf<ClientType>) => string;
389
+ zodSqlSchema: import("zod").ZodString;
390
+ zodNewSchema: import("zod").ZodString;
391
+ initialValue: undefined;
392
+ zodClientSchema: import("zod").ZodString;
393
+ zodValidationSchema: import("zod").ZodString;
394
+ } & {
269
395
  transforms: {
270
- toClient: string;
271
- toDb: string;
396
+ toClient: (dbValue: string) => string;
397
+ toDb: (clientValue: string) => string;
272
398
  };
273
399
  };
274
400
  };
@@ -277,393 +403,833 @@ declare const schemas: {
277
403
  type: "hasMany";
278
404
  fromKey: string;
279
405
  toKey: string | {
280
- sql: {
281
- type: "int";
282
- pk: true;
283
- };
284
- zodDbSchema: import("zod").ZodNumber;
285
- zodClientSchema: import("zod").ZodString;
286
- jsonSchema: any;
287
- defaultValue: string;
288
- transform: (transforms: {
289
- toClient: (dbValue: number) => string;
290
- toDb: (clientValue: string) => number;
291
- }) => {
406
+ config: {
292
407
  sql: {
293
408
  type: "int";
294
409
  pk: true;
295
410
  };
296
- zodDbSchema: import("zod").ZodNumber;
297
- zodClientSchema: import("zod").ZodString;
298
- jsonSchema: any;
299
- defaultValue: string;
300
- toClient: (dbValue: number) => string;
301
- toDb: (clientValue: string) => number;
411
+ zodSqlSchema: import("zod").ZodNumber;
412
+ zodNewSchema: import("zod").ZodString;
413
+ initialValue: string;
414
+ zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodString]>;
415
+ zodValidationSchema: import("zod").ZodString;
416
+ } & {
302
417
  transforms: {
303
- toClient: string;
304
- toDb: string;
418
+ toClient: (dbValue: number) => string | number;
419
+ toDb: (clientValue: string | number) => number;
305
420
  };
306
421
  };
307
422
  } | {
308
- sql: {
309
- type: "varchar";
310
- length: number;
311
- };
312
- dbType: import("zod").ZodString;
313
- zodDbSchema: import("zod").ZodString;
314
- zodClientSchema: import("zod").ZodString;
315
- jsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
316
- $schema?: string | undefined;
317
- definitions?: {
318
- [key: string]: import("zod-to-json-schema").JsonSchema7Type;
319
- } | undefined;
320
- };
321
- defaultValue: string;
322
- client: <ClientType extends import("zod").ZodTypeAny, DefaultValue extends import("zod").TypeOf<ClientType>>(assert?: ClientType | ((tools: {
323
- zod: import("zod").ZodString;
324
- serverType?: never;
325
- }) => ClientType) | undefined, defaultValue?: DefaultValue | (DefaultValue extends Date ? {
326
- default: "CURRENT_TIMESTAMP";
327
- defaultValue: Date;
328
- } : never) | undefined) => {
423
+ config: {
329
424
  sql: {
330
425
  type: "varchar";
331
426
  length: number;
332
427
  };
333
- zodDbSchema: import("zod").ZodString;
334
- zodClientSchema: ClientType;
335
- jsonSchema: any;
336
- defaultValue: DefaultValue | (DefaultValue extends Date ? {
337
- default: "CURRENT_TIMESTAMP";
338
- defaultValue: Date;
339
- } : never);
340
- transform: (transforms: {
341
- toClient: (dbValue: string) => import("zod").TypeOf<ClientType>;
342
- toDb: (clientValue: import("zod").TypeOf<ClientType>) => string;
343
- }) => {
428
+ zodSqlSchema: import("zod").ZodString;
429
+ zodNewSchema: import("zod").ZodString;
430
+ initialValue: undefined;
431
+ zodClientSchema: import("zod").ZodString;
432
+ zodValidationSchema: import("zod").ZodString;
433
+ };
434
+ validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
435
+ sql: import("zod").ZodString;
436
+ initialState: import("zod").ZodString;
437
+ client: import("zod").ZodString;
438
+ }) => TValidationNext)) => {
439
+ config: {
344
440
  sql: {
345
441
  type: "varchar";
346
442
  length: number;
347
443
  };
348
- zodDbSchema: import("zod").ZodString;
349
- zodClientSchema: ClientType;
350
- jsonSchema: any;
351
- defaultValue: DefaultValue;
352
- toClient: (dbValue: string) => import("zod").TypeOf<ClientType>;
353
- toDb: (clientValue: import("zod").TypeOf<ClientType>) => string;
354
- transforms: {
355
- toClient: string;
356
- toDb: string;
444
+ zodSqlSchema: import("zod").ZodString;
445
+ zodNewSchema: import("zod").ZodString;
446
+ initialValue: undefined;
447
+ zodClientSchema: import("zod").ZodString;
448
+ zodValidationSchema: TValidationNext;
449
+ };
450
+ transform: (transforms: {
451
+ toClient: (dbValue: string) => string;
452
+ toDb: (clientValue: string) => string;
453
+ }) => {
454
+ config: {
455
+ sql: {
456
+ type: "varchar";
457
+ length: number;
458
+ };
459
+ zodSqlSchema: import("zod").ZodString;
460
+ zodNewSchema: import("zod").ZodString;
461
+ initialValue: undefined;
462
+ zodClientSchema: import("zod").ZodString;
463
+ zodValidationSchema: TValidationNext;
464
+ } & {
465
+ transforms: {
466
+ toClient: (dbValue: string) => string;
467
+ toDb: (clientValue: string) => string;
468
+ };
357
469
  };
358
470
  };
359
471
  };
360
- db: <ServerType extends import("zod").ZodTypeAny>(assert: ServerType | ((tools: {
361
- zod: import("zod").ZodString;
362
- }) => ServerType)) => {
363
- sql: {
364
- type: "varchar";
365
- length: number;
366
- };
367
- dbType: ServerType;
368
- zodDbSchema: ServerType;
369
- zodClientSchema: import("zod").ZodString;
370
- jsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
371
- $schema?: string | undefined;
372
- definitions?: {
373
- [key: string]: import("zod-to-json-schema").JsonSchema7Type;
374
- } | undefined;
375
- };
376
- defaultValue: import("zod").TypeOf<ServerType>;
377
- client: <ClientType extends import("zod").ZodTypeAny, DefaultValue extends import("zod").TypeOf<ClientType>>(assert?: ClientType | ((tools: {
378
- zod: import("zod").ZodString;
379
- serverType?: ServerType;
380
- }) => ClientType) | undefined, defaultValue?: DefaultValue | (DefaultValue extends Date ? {
381
- default: "CURRENT_TIMESTAMP";
382
- defaultValue: Date;
383
- } : never) | undefined) => {
472
+ client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
473
+ sql: import("zod").ZodString;
474
+ initialState: import("zod").ZodString;
475
+ }) => TClientNext)) => {
476
+ config: {
384
477
  sql: {
385
478
  type: "varchar";
386
479
  length: number;
387
480
  };
388
- zodDbSchema: import("zod").ZodString | ServerType;
389
- zodClientSchema: ClientType;
390
- jsonSchema: any;
391
- defaultValue: DefaultValue | (DefaultValue extends Date ? {
392
- default: "CURRENT_TIMESTAMP";
393
- defaultValue: Date;
394
- } : never);
481
+ zodSqlSchema: import("zod").ZodString;
482
+ zodNewSchema: import("zod").ZodString;
483
+ initialValue: undefined;
484
+ zodClientSchema: TClientNext;
485
+ zodValidationSchema: TClientNext;
486
+ };
487
+ validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
488
+ sql: import("zod").ZodString;
489
+ initialState: import("zod").ZodString;
490
+ client: TClientNext;
491
+ }) => TValidationNext)) => {
492
+ config: {
493
+ sql: {
494
+ type: "varchar";
495
+ length: number;
496
+ };
497
+ zodSqlSchema: import("zod").ZodString;
498
+ zodNewSchema: import("zod").ZodString;
499
+ initialValue: undefined;
500
+ zodClientSchema: TClientNext;
501
+ zodValidationSchema: TValidationNext;
502
+ };
395
503
  transform: (transforms: {
396
- toClient: (dbValue: string) => import("zod").TypeOf<ClientType>;
397
- toDb: (clientValue: import("zod").TypeOf<ClientType>) => string;
504
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
505
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
398
506
  }) => {
507
+ config: {
508
+ sql: {
509
+ type: "varchar";
510
+ length: number;
511
+ };
512
+ zodSqlSchema: import("zod").ZodString;
513
+ zodNewSchema: import("zod").ZodString;
514
+ initialValue: undefined;
515
+ zodClientSchema: TClientNext;
516
+ zodValidationSchema: TValidationNext;
517
+ } & {
518
+ transforms: {
519
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
520
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
521
+ };
522
+ };
523
+ };
524
+ };
525
+ transform: (transforms: {
526
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
527
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
528
+ }) => {
529
+ config: {
399
530
  sql: {
400
531
  type: "varchar";
401
532
  length: number;
402
533
  };
403
- zodDbSchema: import("zod").ZodString | ServerType;
404
- zodClientSchema: ClientType;
405
- jsonSchema: any;
406
- defaultValue: DefaultValue;
407
- toClient: (dbValue: string) => import("zod").TypeOf<ClientType>;
408
- toDb: (clientValue: import("zod").TypeOf<ClientType>) => string;
534
+ zodSqlSchema: import("zod").ZodString;
535
+ zodNewSchema: import("zod").ZodString;
536
+ initialValue: undefined;
537
+ zodClientSchema: TClientNext;
538
+ zodValidationSchema: TClientNext;
539
+ } & {
409
540
  transforms: {
410
- toClient: string;
411
- toDb: string;
541
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
542
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
412
543
  };
413
544
  };
414
545
  };
415
546
  };
416
- } | {
417
- sql: {
418
- type: "int";
419
- };
420
- zodDbSchema: import("zod").ZodNumber;
421
- zodClientSchema: import("zod").ZodString;
422
- jsonSchema: any;
423
- defaultValue: string;
424
547
  transform: (transforms: {
425
- toClient: (dbValue: number) => string;
426
- toDb: (clientValue: string) => number;
548
+ toClient: (dbValue: string) => string;
549
+ toDb: (clientValue: string) => string;
427
550
  }) => {
428
- sql: {
429
- type: "int";
430
- };
431
- zodDbSchema: import("zod").ZodNumber;
432
- zodClientSchema: import("zod").ZodString;
433
- jsonSchema: any;
434
- defaultValue: string;
435
- toClient: (dbValue: number) => string;
436
- toDb: (clientValue: string) => number;
437
- transforms: {
438
- toClient: string;
439
- toDb: string;
440
- };
441
- };
442
- } | {
443
- sql: {
444
- type: "text";
445
- };
446
- zodDbSchema: import("zod").ZodString;
447
- zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
448
- jsonSchema: any;
449
- defaultValue: ("bald" | "fuzzy" | "fluffy" | "poof")[];
450
- toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
451
- toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
452
- transforms: {
453
- toClient: string;
454
- toDb: string;
455
- };
456
- } | {
457
- sql: {
458
- type: "int";
459
- };
460
- zodDbSchema: import("zod").ZodNumber;
461
- zodClientSchema: import("zod").ZodBoolean;
462
- jsonSchema: any;
463
- defaultValue: boolean;
464
- toClient: (dbValue: number) => boolean;
465
- toDb: (clientValue: boolean) => number;
466
- transforms: {
467
- toClient: string;
468
- toDb: string;
469
- };
470
- };
471
- schema: {
472
- _tableName: string;
473
- id: {
474
- sql: {
475
- type: "int";
476
- pk: true;
477
- };
478
- zodDbSchema: import("zod").ZodNumber;
479
- zodClientSchema: import("zod").ZodString;
480
- jsonSchema: any;
481
- defaultValue: string;
482
- transform: (transforms: {
483
- toClient: (dbValue: number) => string;
484
- toDb: (clientValue: string) => number;
485
- }) => {
551
+ config: {
486
552
  sql: {
487
- type: "int";
488
- pk: true;
553
+ type: "varchar";
554
+ length: number;
489
555
  };
490
- zodDbSchema: import("zod").ZodNumber;
556
+ zodSqlSchema: import("zod").ZodString;
557
+ zodNewSchema: import("zod").ZodString;
558
+ initialValue: undefined;
491
559
  zodClientSchema: import("zod").ZodString;
492
- jsonSchema: any;
493
- defaultValue: string;
494
- toClient: (dbValue: number) => string;
495
- toDb: (clientValue: string) => number;
560
+ zodValidationSchema: import("zod").ZodString;
561
+ } & {
496
562
  transforms: {
497
- toClient: string;
498
- toDb: string;
563
+ toClient: (dbValue: string) => string;
564
+ toDb: (clientValue: string) => string;
499
565
  };
500
566
  };
501
567
  };
502
- name: {
503
- sql: {
504
- type: "varchar";
505
- length: number;
506
- };
507
- dbType: import("zod").ZodString;
508
- zodDbSchema: import("zod").ZodString;
509
- zodClientSchema: import("zod").ZodString;
510
- jsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
511
- $schema?: string | undefined;
512
- definitions?: {
513
- [key: string]: import("zod-to-json-schema").JsonSchema7Type;
514
- } | undefined;
515
- };
516
- defaultValue: string;
517
- client: <ClientType extends import("zod").ZodTypeAny, DefaultValue extends import("zod").TypeOf<ClientType>>(assert?: ClientType | ((tools: {
518
- zod: import("zod").ZodString;
519
- serverType?: never;
520
- }) => ClientType) | undefined, defaultValue?: DefaultValue | (DefaultValue extends Date ? {
521
- default: "CURRENT_TIMESTAMP";
522
- defaultValue: Date;
523
- } : never) | undefined) => {
568
+ initialState: <TNewNext extends import("zod").ZodTypeAny, TDefaultNext>(schema: TNewNext | ((tools: {
569
+ sql: import("zod").ZodString;
570
+ }) => TNewNext), defaultValue: () => TDefaultNext) => {
571
+ config: {
524
572
  sql: {
525
573
  type: "varchar";
526
574
  length: number;
527
575
  };
528
- zodDbSchema: import("zod").ZodString;
529
- zodClientSchema: ClientType;
530
- jsonSchema: any;
531
- defaultValue: DefaultValue | (DefaultValue extends Date ? {
532
- default: "CURRENT_TIMESTAMP";
533
- defaultValue: Date;
534
- } : never);
535
- transform: (transforms: {
536
- toClient: (dbValue: string) => import("zod").TypeOf<ClientType>;
537
- toDb: (clientValue: import("zod").TypeOf<ClientType>) => string;
538
- }) => {
576
+ zodSqlSchema: import("zod").ZodString;
577
+ zodNewSchema: TNewNext;
578
+ initialValue: TDefaultNext;
579
+ zodClientSchema: import("zod").ZodString;
580
+ zodValidationSchema: import("zod").ZodString;
581
+ };
582
+ validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
583
+ sql: import("zod").ZodString;
584
+ initialState: TNewNext;
585
+ client: import("zod").ZodString;
586
+ }) => TValidationNext)) => {
587
+ config: {
539
588
  sql: {
540
589
  type: "varchar";
541
590
  length: number;
542
591
  };
543
- zodDbSchema: import("zod").ZodString;
544
- zodClientSchema: ClientType;
545
- jsonSchema: any;
546
- defaultValue: DefaultValue;
547
- toClient: (dbValue: string) => import("zod").TypeOf<ClientType>;
548
- toDb: (clientValue: import("zod").TypeOf<ClientType>) => string;
549
- transforms: {
550
- toClient: string;
551
- toDb: string;
592
+ zodSqlSchema: import("zod").ZodString;
593
+ zodNewSchema: TNewNext;
594
+ initialValue: TDefaultNext;
595
+ zodClientSchema: import("zod").ZodString;
596
+ zodValidationSchema: TValidationNext;
597
+ };
598
+ transform: (transforms: {
599
+ toClient: (dbValue: string) => string;
600
+ toDb: (clientValue: string) => string;
601
+ }) => {
602
+ config: {
603
+ sql: {
604
+ type: "varchar";
605
+ length: number;
606
+ };
607
+ zodSqlSchema: import("zod").ZodString;
608
+ zodNewSchema: TNewNext;
609
+ initialValue: TDefaultNext;
610
+ zodClientSchema: import("zod").ZodString;
611
+ zodValidationSchema: TValidationNext;
612
+ } & {
613
+ transforms: {
614
+ toClient: (dbValue: string) => string;
615
+ toDb: (clientValue: string) => string;
616
+ };
552
617
  };
553
618
  };
554
619
  };
555
- db: <ServerType extends import("zod").ZodTypeAny>(assert: ServerType | ((tools: {
556
- zod: import("zod").ZodString;
557
- }) => ServerType)) => {
558
- sql: {
559
- type: "varchar";
560
- length: number;
561
- };
562
- dbType: ServerType;
563
- zodDbSchema: ServerType;
564
- zodClientSchema: import("zod").ZodString;
565
- jsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
566
- $schema?: string | undefined;
567
- definitions?: {
568
- [key: string]: import("zod-to-json-schema").JsonSchema7Type;
569
- } | undefined;
570
- };
571
- defaultValue: import("zod").TypeOf<ServerType>;
572
- client: <ClientType extends import("zod").ZodTypeAny, DefaultValue extends import("zod").TypeOf<ClientType>>(assert?: ClientType | ((tools: {
573
- zod: import("zod").ZodString;
574
- serverType?: ServerType;
575
- }) => ClientType) | undefined, defaultValue?: DefaultValue | (DefaultValue extends Date ? {
576
- default: "CURRENT_TIMESTAMP";
577
- defaultValue: Date;
578
- } : never) | undefined) => {
620
+ client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
621
+ sql: import("zod").ZodString;
622
+ initialState: TNewNext;
623
+ }) => TClientNext)) => {
624
+ config: {
579
625
  sql: {
580
626
  type: "varchar";
581
627
  length: number;
582
628
  };
583
- zodDbSchema: import("zod").ZodString | ServerType;
584
- zodClientSchema: ClientType;
585
- jsonSchema: any;
586
- defaultValue: DefaultValue | (DefaultValue extends Date ? {
587
- default: "CURRENT_TIMESTAMP";
588
- defaultValue: Date;
589
- } : never);
590
- transform: (transforms: {
591
- toClient: (dbValue: string) => import("zod").TypeOf<ClientType>;
592
- toDb: (clientValue: import("zod").TypeOf<ClientType>) => string;
593
- }) => {
629
+ zodSqlSchema: import("zod").ZodString;
630
+ zodNewSchema: TNewNext;
631
+ initialValue: TDefaultNext;
632
+ zodClientSchema: TClientNext;
633
+ zodValidationSchema: TClientNext;
634
+ };
635
+ validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
636
+ sql: import("zod").ZodString;
637
+ initialState: TNewNext;
638
+ client: TClientNext;
639
+ }) => TValidationNext)) => {
640
+ config: {
594
641
  sql: {
595
642
  type: "varchar";
596
643
  length: number;
597
644
  };
598
- zodDbSchema: import("zod").ZodString | ServerType;
599
- zodClientSchema: ClientType;
600
- jsonSchema: any;
601
- defaultValue: DefaultValue;
602
- toClient: (dbValue: string) => import("zod").TypeOf<ClientType>;
603
- toDb: (clientValue: import("zod").TypeOf<ClientType>) => string;
604
- transforms: {
605
- toClient: string;
606
- toDb: string;
607
- };
645
+ zodSqlSchema: import("zod").ZodString;
646
+ zodNewSchema: TNewNext;
647
+ initialValue: TDefaultNext;
648
+ zodClientSchema: TClientNext;
649
+ zodValidationSchema: TValidationNext;
608
650
  };
609
- };
651
+ transform: (transforms: {
652
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
653
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
654
+ }) => {
655
+ config: {
656
+ sql: {
657
+ type: "varchar";
658
+ length: number;
659
+ };
660
+ zodSqlSchema: import("zod").ZodString;
661
+ zodNewSchema: TNewNext;
662
+ initialValue: TDefaultNext;
663
+ zodClientSchema: TClientNext;
664
+ zodValidationSchema: TValidationNext;
665
+ } & {
666
+ transforms: {
667
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
668
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
669
+ };
670
+ };
671
+ };
672
+ };
673
+ transform: (transforms: {
674
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
675
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
676
+ }) => {
677
+ config: {
678
+ sql: {
679
+ type: "varchar";
680
+ length: number;
681
+ };
682
+ zodSqlSchema: import("zod").ZodString;
683
+ zodNewSchema: TNewNext;
684
+ initialValue: TDefaultNext;
685
+ zodClientSchema: TClientNext;
686
+ zodValidationSchema: TClientNext;
687
+ } & {
688
+ transforms: {
689
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
690
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
691
+ };
692
+ };
693
+ };
694
+ };
695
+ transform: (transforms: {
696
+ toClient: (dbValue: string) => string;
697
+ toDb: (clientValue: string) => string;
698
+ }) => {
699
+ config: {
700
+ sql: {
701
+ type: "varchar";
702
+ length: number;
703
+ };
704
+ zodSqlSchema: import("zod").ZodString;
705
+ zodNewSchema: TNewNext;
706
+ initialValue: TDefaultNext;
707
+ zodClientSchema: import("zod").ZodString;
708
+ zodValidationSchema: import("zod").ZodString;
709
+ } & {
710
+ transforms: {
711
+ toClient: (dbValue: string) => string;
712
+ toDb: (clientValue: string) => string;
713
+ };
714
+ };
610
715
  };
611
716
  };
612
- userId: {
717
+ } | {
718
+ config: {
613
719
  sql: {
614
720
  type: "int";
615
721
  };
616
- zodDbSchema: import("zod").ZodNumber;
722
+ zodSqlSchema: import("zod").ZodNumber;
723
+ zodNewSchema: import("zod").ZodNumber;
724
+ initialValue: undefined;
617
725
  zodClientSchema: import("zod").ZodString;
618
- jsonSchema: any;
619
- defaultValue: string;
726
+ zodValidationSchema: import("zod").ZodString;
727
+ };
728
+ validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
729
+ sql: import("zod").ZodNumber;
730
+ initialState: import("zod").ZodNumber;
731
+ client: import("zod").ZodString;
732
+ }) => TValidationNext)) => {
733
+ config: {
734
+ sql: {
735
+ type: "int";
736
+ };
737
+ zodSqlSchema: import("zod").ZodNumber;
738
+ zodNewSchema: import("zod").ZodNumber;
739
+ initialValue: undefined;
740
+ zodClientSchema: import("zod").ZodString;
741
+ zodValidationSchema: TValidationNext;
742
+ };
620
743
  transform: (transforms: {
621
744
  toClient: (dbValue: number) => string;
622
745
  toDb: (clientValue: string) => number;
623
746
  }) => {
747
+ config: {
748
+ sql: {
749
+ type: "int";
750
+ };
751
+ zodSqlSchema: import("zod").ZodNumber;
752
+ zodNewSchema: import("zod").ZodNumber;
753
+ initialValue: undefined;
754
+ zodClientSchema: import("zod").ZodString;
755
+ zodValidationSchema: TValidationNext;
756
+ } & {
757
+ transforms: {
758
+ toClient: (dbValue: number) => string;
759
+ toDb: (clientValue: string) => number;
760
+ };
761
+ };
762
+ };
763
+ };
764
+ transform: (transforms: {
765
+ toClient: (dbValue: number) => string;
766
+ toDb: (clientValue: string) => number;
767
+ }) => {
768
+ config: {
624
769
  sql: {
625
770
  type: "int";
626
771
  };
627
- zodDbSchema: import("zod").ZodNumber;
772
+ zodSqlSchema: import("zod").ZodNumber;
773
+ zodNewSchema: import("zod").ZodNumber;
774
+ initialValue: undefined;
628
775
  zodClientSchema: import("zod").ZodString;
629
- jsonSchema: any;
630
- defaultValue: string;
631
- toClient: (dbValue: number) => string;
632
- toDb: (clientValue: string) => number;
776
+ zodValidationSchema: import("zod").ZodString;
777
+ } & {
633
778
  transforms: {
634
- toClient: string;
635
- toDb: string;
779
+ toClient: (dbValue: number) => string;
780
+ toDb: (clientValue: string) => number;
636
781
  };
637
782
  };
638
783
  };
639
- fluffynessScale: {
784
+ } | {
785
+ config: {
640
786
  sql: {
641
787
  type: "text";
642
788
  };
643
- zodDbSchema: import("zod").ZodString;
789
+ zodSqlSchema: import("zod").ZodString;
790
+ zodNewSchema: import("zod").ZodString;
791
+ initialValue: undefined;
644
792
  zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
645
- jsonSchema: any;
646
- defaultValue: ("bald" | "fuzzy" | "fluffy" | "poof")[];
647
- toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
648
- toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
793
+ zodValidationSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
794
+ } & {
649
795
  transforms: {
650
- toClient: string;
651
- toDb: string;
796
+ toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
797
+ toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
652
798
  };
653
799
  };
654
- favourite: {
800
+ } | {
801
+ config: {
655
802
  sql: {
656
803
  type: "int";
657
804
  };
658
- zodDbSchema: import("zod").ZodNumber;
805
+ zodSqlSchema: import("zod").ZodNumber;
806
+ zodNewSchema: import("zod").ZodNumber;
807
+ initialValue: undefined;
659
808
  zodClientSchema: import("zod").ZodBoolean;
660
- jsonSchema: any;
661
- defaultValue: boolean;
662
- toClient: (dbValue: number) => boolean;
663
- toDb: (clientValue: boolean) => number;
809
+ zodValidationSchema: import("zod").ZodBoolean;
810
+ } & {
664
811
  transforms: {
665
- toClient: string;
666
- toDb: string;
812
+ toClient: (dbValue: number) => boolean;
813
+ toDb: (clientValue: boolean) => number;
814
+ };
815
+ };
816
+ };
817
+ schema: {
818
+ _tableName: string;
819
+ id: {
820
+ config: {
821
+ sql: {
822
+ type: "int";
823
+ pk: true;
824
+ };
825
+ zodSqlSchema: import("zod").ZodNumber;
826
+ zodNewSchema: import("zod").ZodString;
827
+ initialValue: string;
828
+ zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodString]>;
829
+ zodValidationSchema: import("zod").ZodString;
830
+ } & {
831
+ transforms: {
832
+ toClient: (dbValue: number) => string | number;
833
+ toDb: (clientValue: string | number) => number;
834
+ };
835
+ };
836
+ };
837
+ name: {
838
+ config: {
839
+ sql: {
840
+ type: "varchar";
841
+ length: number;
842
+ };
843
+ zodSqlSchema: import("zod").ZodString;
844
+ zodNewSchema: import("zod").ZodString;
845
+ initialValue: undefined;
846
+ zodClientSchema: import("zod").ZodString;
847
+ zodValidationSchema: import("zod").ZodString;
848
+ };
849
+ validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
850
+ sql: import("zod").ZodString;
851
+ initialState: import("zod").ZodString;
852
+ client: import("zod").ZodString;
853
+ }) => TValidationNext)) => {
854
+ config: {
855
+ sql: {
856
+ type: "varchar";
857
+ length: number;
858
+ };
859
+ zodSqlSchema: import("zod").ZodString;
860
+ zodNewSchema: import("zod").ZodString;
861
+ initialValue: undefined;
862
+ zodClientSchema: import("zod").ZodString;
863
+ zodValidationSchema: TValidationNext;
864
+ };
865
+ transform: (transforms: {
866
+ toClient: (dbValue: string) => string;
867
+ toDb: (clientValue: string) => string;
868
+ }) => {
869
+ config: {
870
+ sql: {
871
+ type: "varchar";
872
+ length: number;
873
+ };
874
+ zodSqlSchema: import("zod").ZodString;
875
+ zodNewSchema: import("zod").ZodString;
876
+ initialValue: undefined;
877
+ zodClientSchema: import("zod").ZodString;
878
+ zodValidationSchema: TValidationNext;
879
+ } & {
880
+ transforms: {
881
+ toClient: (dbValue: string) => string;
882
+ toDb: (clientValue: string) => string;
883
+ };
884
+ };
885
+ };
886
+ };
887
+ client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
888
+ sql: import("zod").ZodString;
889
+ initialState: import("zod").ZodString;
890
+ }) => TClientNext)) => {
891
+ config: {
892
+ sql: {
893
+ type: "varchar";
894
+ length: number;
895
+ };
896
+ zodSqlSchema: import("zod").ZodString;
897
+ zodNewSchema: import("zod").ZodString;
898
+ initialValue: undefined;
899
+ zodClientSchema: TClientNext;
900
+ zodValidationSchema: TClientNext;
901
+ };
902
+ validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
903
+ sql: import("zod").ZodString;
904
+ initialState: import("zod").ZodString;
905
+ client: TClientNext;
906
+ }) => TValidationNext)) => {
907
+ config: {
908
+ sql: {
909
+ type: "varchar";
910
+ length: number;
911
+ };
912
+ zodSqlSchema: import("zod").ZodString;
913
+ zodNewSchema: import("zod").ZodString;
914
+ initialValue: undefined;
915
+ zodClientSchema: TClientNext;
916
+ zodValidationSchema: TValidationNext;
917
+ };
918
+ transform: (transforms: {
919
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
920
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
921
+ }) => {
922
+ config: {
923
+ sql: {
924
+ type: "varchar";
925
+ length: number;
926
+ };
927
+ zodSqlSchema: import("zod").ZodString;
928
+ zodNewSchema: import("zod").ZodString;
929
+ initialValue: undefined;
930
+ zodClientSchema: TClientNext;
931
+ zodValidationSchema: TValidationNext;
932
+ } & {
933
+ transforms: {
934
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
935
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
936
+ };
937
+ };
938
+ };
939
+ };
940
+ transform: (transforms: {
941
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
942
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
943
+ }) => {
944
+ config: {
945
+ sql: {
946
+ type: "varchar";
947
+ length: number;
948
+ };
949
+ zodSqlSchema: import("zod").ZodString;
950
+ zodNewSchema: import("zod").ZodString;
951
+ initialValue: undefined;
952
+ zodClientSchema: TClientNext;
953
+ zodValidationSchema: TClientNext;
954
+ } & {
955
+ transforms: {
956
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
957
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
958
+ };
959
+ };
960
+ };
961
+ };
962
+ transform: (transforms: {
963
+ toClient: (dbValue: string) => string;
964
+ toDb: (clientValue: string) => string;
965
+ }) => {
966
+ config: {
967
+ sql: {
968
+ type: "varchar";
969
+ length: number;
970
+ };
971
+ zodSqlSchema: import("zod").ZodString;
972
+ zodNewSchema: import("zod").ZodString;
973
+ initialValue: undefined;
974
+ zodClientSchema: import("zod").ZodString;
975
+ zodValidationSchema: import("zod").ZodString;
976
+ } & {
977
+ transforms: {
978
+ toClient: (dbValue: string) => string;
979
+ toDb: (clientValue: string) => string;
980
+ };
981
+ };
982
+ };
983
+ initialState: <TNewNext extends import("zod").ZodTypeAny, TDefaultNext>(schema: TNewNext | ((tools: {
984
+ sql: import("zod").ZodString;
985
+ }) => TNewNext), defaultValue: () => TDefaultNext) => {
986
+ config: {
987
+ sql: {
988
+ type: "varchar";
989
+ length: number;
990
+ };
991
+ zodSqlSchema: import("zod").ZodString;
992
+ zodNewSchema: TNewNext;
993
+ initialValue: TDefaultNext;
994
+ zodClientSchema: import("zod").ZodString;
995
+ zodValidationSchema: import("zod").ZodString;
996
+ };
997
+ validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
998
+ sql: import("zod").ZodString;
999
+ initialState: TNewNext;
1000
+ client: import("zod").ZodString;
1001
+ }) => TValidationNext)) => {
1002
+ config: {
1003
+ sql: {
1004
+ type: "varchar";
1005
+ length: number;
1006
+ };
1007
+ zodSqlSchema: import("zod").ZodString;
1008
+ zodNewSchema: TNewNext;
1009
+ initialValue: TDefaultNext;
1010
+ zodClientSchema: import("zod").ZodString;
1011
+ zodValidationSchema: TValidationNext;
1012
+ };
1013
+ transform: (transforms: {
1014
+ toClient: (dbValue: string) => string;
1015
+ toDb: (clientValue: string) => string;
1016
+ }) => {
1017
+ config: {
1018
+ sql: {
1019
+ type: "varchar";
1020
+ length: number;
1021
+ };
1022
+ zodSqlSchema: import("zod").ZodString;
1023
+ zodNewSchema: TNewNext;
1024
+ initialValue: TDefaultNext;
1025
+ zodClientSchema: import("zod").ZodString;
1026
+ zodValidationSchema: TValidationNext;
1027
+ } & {
1028
+ transforms: {
1029
+ toClient: (dbValue: string) => string;
1030
+ toDb: (clientValue: string) => string;
1031
+ };
1032
+ };
1033
+ };
1034
+ };
1035
+ client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
1036
+ sql: import("zod").ZodString;
1037
+ initialState: TNewNext;
1038
+ }) => TClientNext)) => {
1039
+ config: {
1040
+ sql: {
1041
+ type: "varchar";
1042
+ length: number;
1043
+ };
1044
+ zodSqlSchema: import("zod").ZodString;
1045
+ zodNewSchema: TNewNext;
1046
+ initialValue: TDefaultNext;
1047
+ zodClientSchema: TClientNext;
1048
+ zodValidationSchema: TClientNext;
1049
+ };
1050
+ validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
1051
+ sql: import("zod").ZodString;
1052
+ initialState: TNewNext;
1053
+ client: TClientNext;
1054
+ }) => TValidationNext)) => {
1055
+ config: {
1056
+ sql: {
1057
+ type: "varchar";
1058
+ length: number;
1059
+ };
1060
+ zodSqlSchema: import("zod").ZodString;
1061
+ zodNewSchema: TNewNext;
1062
+ initialValue: TDefaultNext;
1063
+ zodClientSchema: TClientNext;
1064
+ zodValidationSchema: TValidationNext;
1065
+ };
1066
+ transform: (transforms: {
1067
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1068
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1069
+ }) => {
1070
+ config: {
1071
+ sql: {
1072
+ type: "varchar";
1073
+ length: number;
1074
+ };
1075
+ zodSqlSchema: import("zod").ZodString;
1076
+ zodNewSchema: TNewNext;
1077
+ initialValue: TDefaultNext;
1078
+ zodClientSchema: TClientNext;
1079
+ zodValidationSchema: TValidationNext;
1080
+ } & {
1081
+ transforms: {
1082
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1083
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1084
+ };
1085
+ };
1086
+ };
1087
+ };
1088
+ transform: (transforms: {
1089
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1090
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1091
+ }) => {
1092
+ config: {
1093
+ sql: {
1094
+ type: "varchar";
1095
+ length: number;
1096
+ };
1097
+ zodSqlSchema: import("zod").ZodString;
1098
+ zodNewSchema: TNewNext;
1099
+ initialValue: TDefaultNext;
1100
+ zodClientSchema: TClientNext;
1101
+ zodValidationSchema: TClientNext;
1102
+ } & {
1103
+ transforms: {
1104
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1105
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1106
+ };
1107
+ };
1108
+ };
1109
+ };
1110
+ transform: (transforms: {
1111
+ toClient: (dbValue: string) => string;
1112
+ toDb: (clientValue: string) => string;
1113
+ }) => {
1114
+ config: {
1115
+ sql: {
1116
+ type: "varchar";
1117
+ length: number;
1118
+ };
1119
+ zodSqlSchema: import("zod").ZodString;
1120
+ zodNewSchema: TNewNext;
1121
+ initialValue: TDefaultNext;
1122
+ zodClientSchema: import("zod").ZodString;
1123
+ zodValidationSchema: import("zod").ZodString;
1124
+ } & {
1125
+ transforms: {
1126
+ toClient: (dbValue: string) => string;
1127
+ toDb: (clientValue: string) => string;
1128
+ };
1129
+ };
1130
+ };
1131
+ };
1132
+ };
1133
+ userId: {
1134
+ config: {
1135
+ sql: {
1136
+ type: "int";
1137
+ };
1138
+ zodSqlSchema: import("zod").ZodNumber;
1139
+ zodNewSchema: import("zod").ZodNumber;
1140
+ initialValue: undefined;
1141
+ zodClientSchema: import("zod").ZodString;
1142
+ zodValidationSchema: import("zod").ZodString;
1143
+ };
1144
+ validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
1145
+ sql: import("zod").ZodNumber;
1146
+ initialState: import("zod").ZodNumber;
1147
+ client: import("zod").ZodString;
1148
+ }) => TValidationNext)) => {
1149
+ config: {
1150
+ sql: {
1151
+ type: "int";
1152
+ };
1153
+ zodSqlSchema: import("zod").ZodNumber;
1154
+ zodNewSchema: import("zod").ZodNumber;
1155
+ initialValue: undefined;
1156
+ zodClientSchema: import("zod").ZodString;
1157
+ zodValidationSchema: TValidationNext;
1158
+ };
1159
+ transform: (transforms: {
1160
+ toClient: (dbValue: number) => string;
1161
+ toDb: (clientValue: string) => number;
1162
+ }) => {
1163
+ config: {
1164
+ sql: {
1165
+ type: "int";
1166
+ };
1167
+ zodSqlSchema: import("zod").ZodNumber;
1168
+ zodNewSchema: import("zod").ZodNumber;
1169
+ initialValue: undefined;
1170
+ zodClientSchema: import("zod").ZodString;
1171
+ zodValidationSchema: TValidationNext;
1172
+ } & {
1173
+ transforms: {
1174
+ toClient: (dbValue: number) => string;
1175
+ toDb: (clientValue: string) => number;
1176
+ };
1177
+ };
1178
+ };
1179
+ };
1180
+ transform: (transforms: {
1181
+ toClient: (dbValue: number) => string;
1182
+ toDb: (clientValue: string) => number;
1183
+ }) => {
1184
+ config: {
1185
+ sql: {
1186
+ type: "int";
1187
+ };
1188
+ zodSqlSchema: import("zod").ZodNumber;
1189
+ zodNewSchema: import("zod").ZodNumber;
1190
+ initialValue: undefined;
1191
+ zodClientSchema: import("zod").ZodString;
1192
+ zodValidationSchema: import("zod").ZodString;
1193
+ } & {
1194
+ transforms: {
1195
+ toClient: (dbValue: number) => string;
1196
+ toDb: (clientValue: string) => number;
1197
+ };
1198
+ };
1199
+ };
1200
+ };
1201
+ fluffynessScale: {
1202
+ config: {
1203
+ sql: {
1204
+ type: "text";
1205
+ };
1206
+ zodSqlSchema: import("zod").ZodString;
1207
+ zodNewSchema: import("zod").ZodString;
1208
+ initialValue: undefined;
1209
+ zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
1210
+ zodValidationSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
1211
+ } & {
1212
+ transforms: {
1213
+ toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
1214
+ toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
1215
+ };
1216
+ };
1217
+ };
1218
+ favourite: {
1219
+ config: {
1220
+ sql: {
1221
+ type: "int";
1222
+ };
1223
+ zodSqlSchema: import("zod").ZodNumber;
1224
+ zodNewSchema: import("zod").ZodNumber;
1225
+ initialValue: undefined;
1226
+ zodClientSchema: import("zod").ZodBoolean;
1227
+ zodValidationSchema: import("zod").ZodBoolean;
1228
+ } & {
1229
+ transforms: {
1230
+ toClient: (dbValue: number) => boolean;
1231
+ toDb: (clientValue: boolean) => number;
1232
+ };
667
1233
  };
668
1234
  };
669
1235
  };
@@ -673,199 +1239,419 @@ declare const schemas: {
673
1239
  pet: {
674
1240
  _tableName: string;
675
1241
  id: {
676
- sql: {
677
- type: "int";
678
- pk: true;
679
- };
680
- zodDbSchema: import("zod").ZodNumber;
681
- zodClientSchema: import("zod").ZodString;
682
- jsonSchema: any;
683
- defaultValue: string;
684
- transform: (transforms: {
685
- toClient: (dbValue: number) => string;
686
- toDb: (clientValue: string) => number;
687
- }) => {
1242
+ config: {
688
1243
  sql: {
689
1244
  type: "int";
690
1245
  pk: true;
691
1246
  };
692
- zodDbSchema: import("zod").ZodNumber;
693
- zodClientSchema: import("zod").ZodString;
694
- jsonSchema: any;
695
- defaultValue: string;
696
- toClient: (dbValue: number) => string;
697
- toDb: (clientValue: string) => number;
1247
+ zodSqlSchema: import("zod").ZodNumber;
1248
+ zodNewSchema: import("zod").ZodString;
1249
+ initialValue: string;
1250
+ zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodString]>;
1251
+ zodValidationSchema: import("zod").ZodString;
1252
+ } & {
698
1253
  transforms: {
699
- toClient: string;
700
- toDb: string;
1254
+ toClient: (dbValue: number) => string | number;
1255
+ toDb: (clientValue: string | number) => number;
701
1256
  };
702
1257
  };
703
1258
  };
704
1259
  name: {
705
- sql: {
706
- type: "varchar";
707
- length: number;
708
- };
709
- dbType: import("zod").ZodString;
710
- zodDbSchema: import("zod").ZodString;
711
- zodClientSchema: import("zod").ZodString;
712
- jsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
713
- $schema?: string | undefined;
714
- definitions?: {
715
- [key: string]: import("zod-to-json-schema").JsonSchema7Type;
716
- } | undefined;
717
- };
718
- defaultValue: string;
719
- client: <ClientType extends import("zod").ZodTypeAny, DefaultValue extends import("zod").TypeOf<ClientType>>(assert?: ClientType | ((tools: {
720
- zod: import("zod").ZodString;
721
- serverType?: never;
722
- }) => ClientType) | undefined, defaultValue?: DefaultValue | (DefaultValue extends Date ? {
723
- default: "CURRENT_TIMESTAMP";
724
- defaultValue: Date;
725
- } : never) | undefined) => {
1260
+ config: {
726
1261
  sql: {
727
1262
  type: "varchar";
728
1263
  length: number;
729
1264
  };
730
- zodDbSchema: import("zod").ZodString;
731
- zodClientSchema: ClientType;
732
- jsonSchema: any;
733
- defaultValue: DefaultValue | (DefaultValue extends Date ? {
734
- default: "CURRENT_TIMESTAMP";
735
- defaultValue: Date;
736
- } : never);
1265
+ zodSqlSchema: import("zod").ZodString;
1266
+ zodNewSchema: import("zod").ZodString;
1267
+ initialValue: undefined;
1268
+ zodClientSchema: import("zod").ZodString;
1269
+ zodValidationSchema: import("zod").ZodString;
1270
+ };
1271
+ validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
1272
+ sql: import("zod").ZodString;
1273
+ initialState: import("zod").ZodString;
1274
+ client: import("zod").ZodString;
1275
+ }) => TValidationNext)) => {
1276
+ config: {
1277
+ sql: {
1278
+ type: "varchar";
1279
+ length: number;
1280
+ };
1281
+ zodSqlSchema: import("zod").ZodString;
1282
+ zodNewSchema: import("zod").ZodString;
1283
+ initialValue: undefined;
1284
+ zodClientSchema: import("zod").ZodString;
1285
+ zodValidationSchema: TValidationNext;
1286
+ };
737
1287
  transform: (transforms: {
738
- toClient: (dbValue: string) => import("zod").TypeOf<ClientType>;
739
- toDb: (clientValue: import("zod").TypeOf<ClientType>) => string;
1288
+ toClient: (dbValue: string) => string;
1289
+ toDb: (clientValue: string) => string;
740
1290
  }) => {
1291
+ config: {
1292
+ sql: {
1293
+ type: "varchar";
1294
+ length: number;
1295
+ };
1296
+ zodSqlSchema: import("zod").ZodString;
1297
+ zodNewSchema: import("zod").ZodString;
1298
+ initialValue: undefined;
1299
+ zodClientSchema: import("zod").ZodString;
1300
+ zodValidationSchema: TValidationNext;
1301
+ } & {
1302
+ transforms: {
1303
+ toClient: (dbValue: string) => string;
1304
+ toDb: (clientValue: string) => string;
1305
+ };
1306
+ };
1307
+ };
1308
+ };
1309
+ client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
1310
+ sql: import("zod").ZodString;
1311
+ initialState: import("zod").ZodString;
1312
+ }) => TClientNext)) => {
1313
+ config: {
741
1314
  sql: {
742
1315
  type: "varchar";
743
1316
  length: number;
744
1317
  };
745
- zodDbSchema: import("zod").ZodString;
746
- zodClientSchema: ClientType;
747
- jsonSchema: any;
748
- defaultValue: DefaultValue;
749
- toClient: (dbValue: string) => import("zod").TypeOf<ClientType>;
750
- toDb: (clientValue: import("zod").TypeOf<ClientType>) => string;
751
- transforms: {
752
- toClient: string;
753
- toDb: string;
1318
+ zodSqlSchema: import("zod").ZodString;
1319
+ zodNewSchema: import("zod").ZodString;
1320
+ initialValue: undefined;
1321
+ zodClientSchema: TClientNext;
1322
+ zodValidationSchema: TClientNext;
1323
+ };
1324
+ validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
1325
+ sql: import("zod").ZodString;
1326
+ initialState: import("zod").ZodString;
1327
+ client: TClientNext;
1328
+ }) => TValidationNext)) => {
1329
+ config: {
1330
+ sql: {
1331
+ type: "varchar";
1332
+ length: number;
1333
+ };
1334
+ zodSqlSchema: import("zod").ZodString;
1335
+ zodNewSchema: import("zod").ZodString;
1336
+ initialValue: undefined;
1337
+ zodClientSchema: TClientNext;
1338
+ zodValidationSchema: TValidationNext;
1339
+ };
1340
+ transform: (transforms: {
1341
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1342
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1343
+ }) => {
1344
+ config: {
1345
+ sql: {
1346
+ type: "varchar";
1347
+ length: number;
1348
+ };
1349
+ zodSqlSchema: import("zod").ZodString;
1350
+ zodNewSchema: import("zod").ZodString;
1351
+ initialValue: undefined;
1352
+ zodClientSchema: TClientNext;
1353
+ zodValidationSchema: TValidationNext;
1354
+ } & {
1355
+ transforms: {
1356
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1357
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1358
+ };
1359
+ };
1360
+ };
1361
+ };
1362
+ transform: (transforms: {
1363
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1364
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1365
+ }) => {
1366
+ config: {
1367
+ sql: {
1368
+ type: "varchar";
1369
+ length: number;
1370
+ };
1371
+ zodSqlSchema: import("zod").ZodString;
1372
+ zodNewSchema: import("zod").ZodString;
1373
+ initialValue: undefined;
1374
+ zodClientSchema: TClientNext;
1375
+ zodValidationSchema: TClientNext;
1376
+ } & {
1377
+ transforms: {
1378
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1379
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1380
+ };
754
1381
  };
755
1382
  };
756
1383
  };
757
- db: <ServerType extends import("zod").ZodTypeAny>(assert: ServerType | ((tools: {
758
- zod: import("zod").ZodString;
759
- }) => ServerType)) => {
760
- sql: {
761
- type: "varchar";
762
- length: number;
1384
+ transform: (transforms: {
1385
+ toClient: (dbValue: string) => string;
1386
+ toDb: (clientValue: string) => string;
1387
+ }) => {
1388
+ config: {
1389
+ sql: {
1390
+ type: "varchar";
1391
+ length: number;
1392
+ };
1393
+ zodSqlSchema: import("zod").ZodString;
1394
+ zodNewSchema: import("zod").ZodString;
1395
+ initialValue: undefined;
1396
+ zodClientSchema: import("zod").ZodString;
1397
+ zodValidationSchema: import("zod").ZodString;
1398
+ } & {
1399
+ transforms: {
1400
+ toClient: (dbValue: string) => string;
1401
+ toDb: (clientValue: string) => string;
1402
+ };
763
1403
  };
764
- dbType: ServerType;
765
- zodDbSchema: ServerType;
766
- zodClientSchema: import("zod").ZodString;
767
- jsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
768
- $schema?: string | undefined;
769
- definitions?: {
770
- [key: string]: import("zod-to-json-schema").JsonSchema7Type;
771
- } | undefined;
772
- };
773
- defaultValue: import("zod").TypeOf<ServerType>;
774
- client: <ClientType extends import("zod").ZodTypeAny, DefaultValue extends import("zod").TypeOf<ClientType>>(assert?: ClientType | ((tools: {
775
- zod: import("zod").ZodString;
776
- serverType?: ServerType;
777
- }) => ClientType) | undefined, defaultValue?: DefaultValue | (DefaultValue extends Date ? {
778
- default: "CURRENT_TIMESTAMP";
779
- defaultValue: Date;
780
- } : never) | undefined) => {
1404
+ };
1405
+ initialState: <TNewNext extends import("zod").ZodTypeAny, TDefaultNext>(schema: TNewNext | ((tools: {
1406
+ sql: import("zod").ZodString;
1407
+ }) => TNewNext), defaultValue: () => TDefaultNext) => {
1408
+ config: {
781
1409
  sql: {
782
1410
  type: "varchar";
783
1411
  length: number;
784
1412
  };
785
- zodDbSchema: import("zod").ZodString | ServerType;
786
- zodClientSchema: ClientType;
787
- jsonSchema: any;
788
- defaultValue: DefaultValue | (DefaultValue extends Date ? {
789
- default: "CURRENT_TIMESTAMP";
790
- defaultValue: Date;
791
- } : never);
1413
+ zodSqlSchema: import("zod").ZodString;
1414
+ zodNewSchema: TNewNext;
1415
+ initialValue: TDefaultNext;
1416
+ zodClientSchema: import("zod").ZodString;
1417
+ zodValidationSchema: import("zod").ZodString;
1418
+ };
1419
+ validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
1420
+ sql: import("zod").ZodString;
1421
+ initialState: TNewNext;
1422
+ client: import("zod").ZodString;
1423
+ }) => TValidationNext)) => {
1424
+ config: {
1425
+ sql: {
1426
+ type: "varchar";
1427
+ length: number;
1428
+ };
1429
+ zodSqlSchema: import("zod").ZodString;
1430
+ zodNewSchema: TNewNext;
1431
+ initialValue: TDefaultNext;
1432
+ zodClientSchema: import("zod").ZodString;
1433
+ zodValidationSchema: TValidationNext;
1434
+ };
792
1435
  transform: (transforms: {
793
- toClient: (dbValue: string) => import("zod").TypeOf<ClientType>;
794
- toDb: (clientValue: import("zod").TypeOf<ClientType>) => string;
1436
+ toClient: (dbValue: string) => string;
1437
+ toDb: (clientValue: string) => string;
795
1438
  }) => {
1439
+ config: {
1440
+ sql: {
1441
+ type: "varchar";
1442
+ length: number;
1443
+ };
1444
+ zodSqlSchema: import("zod").ZodString;
1445
+ zodNewSchema: TNewNext;
1446
+ initialValue: TDefaultNext;
1447
+ zodClientSchema: import("zod").ZodString;
1448
+ zodValidationSchema: TValidationNext;
1449
+ } & {
1450
+ transforms: {
1451
+ toClient: (dbValue: string) => string;
1452
+ toDb: (clientValue: string) => string;
1453
+ };
1454
+ };
1455
+ };
1456
+ };
1457
+ client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
1458
+ sql: import("zod").ZodString;
1459
+ initialState: TNewNext;
1460
+ }) => TClientNext)) => {
1461
+ config: {
1462
+ sql: {
1463
+ type: "varchar";
1464
+ length: number;
1465
+ };
1466
+ zodSqlSchema: import("zod").ZodString;
1467
+ zodNewSchema: TNewNext;
1468
+ initialValue: TDefaultNext;
1469
+ zodClientSchema: TClientNext;
1470
+ zodValidationSchema: TClientNext;
1471
+ };
1472
+ validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
1473
+ sql: import("zod").ZodString;
1474
+ initialState: TNewNext;
1475
+ client: TClientNext;
1476
+ }) => TValidationNext)) => {
1477
+ config: {
1478
+ sql: {
1479
+ type: "varchar";
1480
+ length: number;
1481
+ };
1482
+ zodSqlSchema: import("zod").ZodString;
1483
+ zodNewSchema: TNewNext;
1484
+ initialValue: TDefaultNext;
1485
+ zodClientSchema: TClientNext;
1486
+ zodValidationSchema: TValidationNext;
1487
+ };
1488
+ transform: (transforms: {
1489
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1490
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1491
+ }) => {
1492
+ config: {
1493
+ sql: {
1494
+ type: "varchar";
1495
+ length: number;
1496
+ };
1497
+ zodSqlSchema: import("zod").ZodString;
1498
+ zodNewSchema: TNewNext;
1499
+ initialValue: TDefaultNext;
1500
+ zodClientSchema: TClientNext;
1501
+ zodValidationSchema: TValidationNext;
1502
+ } & {
1503
+ transforms: {
1504
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1505
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1506
+ };
1507
+ };
1508
+ };
1509
+ };
1510
+ transform: (transforms: {
1511
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1512
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1513
+ }) => {
1514
+ config: {
1515
+ sql: {
1516
+ type: "varchar";
1517
+ length: number;
1518
+ };
1519
+ zodSqlSchema: import("zod").ZodString;
1520
+ zodNewSchema: TNewNext;
1521
+ initialValue: TDefaultNext;
1522
+ zodClientSchema: TClientNext;
1523
+ zodValidationSchema: TClientNext;
1524
+ } & {
1525
+ transforms: {
1526
+ toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1527
+ toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1528
+ };
1529
+ };
1530
+ };
1531
+ };
1532
+ transform: (transforms: {
1533
+ toClient: (dbValue: string) => string;
1534
+ toDb: (clientValue: string) => string;
1535
+ }) => {
1536
+ config: {
796
1537
  sql: {
797
1538
  type: "varchar";
798
1539
  length: number;
799
1540
  };
800
- zodDbSchema: import("zod").ZodString | ServerType;
801
- zodClientSchema: ClientType;
802
- jsonSchema: any;
803
- defaultValue: DefaultValue;
804
- toClient: (dbValue: string) => import("zod").TypeOf<ClientType>;
805
- toDb: (clientValue: import("zod").TypeOf<ClientType>) => string;
1541
+ zodSqlSchema: import("zod").ZodString;
1542
+ zodNewSchema: TNewNext;
1543
+ initialValue: TDefaultNext;
1544
+ zodClientSchema: import("zod").ZodString;
1545
+ zodValidationSchema: import("zod").ZodString;
1546
+ } & {
806
1547
  transforms: {
807
- toClient: string;
808
- toDb: string;
1548
+ toClient: (dbValue: string) => string;
1549
+ toDb: (clientValue: string) => string;
809
1550
  };
810
1551
  };
811
1552
  };
812
1553
  };
813
1554
  };
814
1555
  userId: {
815
- sql: {
816
- type: "int";
817
- };
818
- zodDbSchema: import("zod").ZodNumber;
819
- zodClientSchema: import("zod").ZodString;
820
- jsonSchema: any;
821
- defaultValue: string;
822
- transform: (transforms: {
823
- toClient: (dbValue: number) => string;
824
- toDb: (clientValue: string) => number;
825
- }) => {
1556
+ config: {
826
1557
  sql: {
827
1558
  type: "int";
828
1559
  };
829
- zodDbSchema: import("zod").ZodNumber;
1560
+ zodSqlSchema: import("zod").ZodNumber;
1561
+ zodNewSchema: import("zod").ZodNumber;
1562
+ initialValue: undefined;
830
1563
  zodClientSchema: import("zod").ZodString;
831
- jsonSchema: any;
832
- defaultValue: string;
1564
+ zodValidationSchema: import("zod").ZodString;
1565
+ };
1566
+ validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
1567
+ sql: import("zod").ZodNumber;
1568
+ initialState: import("zod").ZodNumber;
1569
+ client: import("zod").ZodString;
1570
+ }) => TValidationNext)) => {
1571
+ config: {
1572
+ sql: {
1573
+ type: "int";
1574
+ };
1575
+ zodSqlSchema: import("zod").ZodNumber;
1576
+ zodNewSchema: import("zod").ZodNumber;
1577
+ initialValue: undefined;
1578
+ zodClientSchema: import("zod").ZodString;
1579
+ zodValidationSchema: TValidationNext;
1580
+ };
1581
+ transform: (transforms: {
1582
+ toClient: (dbValue: number) => string;
1583
+ toDb: (clientValue: string) => number;
1584
+ }) => {
1585
+ config: {
1586
+ sql: {
1587
+ type: "int";
1588
+ };
1589
+ zodSqlSchema: import("zod").ZodNumber;
1590
+ zodNewSchema: import("zod").ZodNumber;
1591
+ initialValue: undefined;
1592
+ zodClientSchema: import("zod").ZodString;
1593
+ zodValidationSchema: TValidationNext;
1594
+ } & {
1595
+ transforms: {
1596
+ toClient: (dbValue: number) => string;
1597
+ toDb: (clientValue: string) => number;
1598
+ };
1599
+ };
1600
+ };
1601
+ };
1602
+ transform: (transforms: {
833
1603
  toClient: (dbValue: number) => string;
834
1604
  toDb: (clientValue: string) => number;
835
- transforms: {
836
- toClient: string;
837
- toDb: string;
1605
+ }) => {
1606
+ config: {
1607
+ sql: {
1608
+ type: "int";
1609
+ };
1610
+ zodSqlSchema: import("zod").ZodNumber;
1611
+ zodNewSchema: import("zod").ZodNumber;
1612
+ initialValue: undefined;
1613
+ zodClientSchema: import("zod").ZodString;
1614
+ zodValidationSchema: import("zod").ZodString;
1615
+ } & {
1616
+ transforms: {
1617
+ toClient: (dbValue: number) => string;
1618
+ toDb: (clientValue: string) => number;
1619
+ };
838
1620
  };
839
1621
  };
840
1622
  };
841
1623
  fluffynessScale: {
842
- sql: {
843
- type: "text";
844
- };
845
- zodDbSchema: import("zod").ZodString;
846
- zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
847
- jsonSchema: any;
848
- defaultValue: ("bald" | "fuzzy" | "fluffy" | "poof")[];
849
- toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
850
- toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
851
- transforms: {
852
- toClient: string;
853
- toDb: string;
1624
+ config: {
1625
+ sql: {
1626
+ type: "text";
1627
+ };
1628
+ zodSqlSchema: import("zod").ZodString;
1629
+ zodNewSchema: import("zod").ZodString;
1630
+ initialValue: undefined;
1631
+ zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
1632
+ zodValidationSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
1633
+ } & {
1634
+ transforms: {
1635
+ toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
1636
+ toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
1637
+ };
854
1638
  };
855
1639
  };
856
1640
  favourite: {
857
- sql: {
858
- type: "int";
859
- };
860
- zodDbSchema: import("zod").ZodNumber;
861
- zodClientSchema: import("zod").ZodBoolean;
862
- jsonSchema: any;
863
- defaultValue: boolean;
864
- toClient: (dbValue: number) => boolean;
865
- toDb: (clientValue: boolean) => number;
866
- transforms: {
867
- toClient: string;
868
- toDb: string;
1641
+ config: {
1642
+ sql: {
1643
+ type: "int";
1644
+ };
1645
+ zodSqlSchema: import("zod").ZodNumber;
1646
+ zodNewSchema: import("zod").ZodNumber;
1647
+ initialValue: undefined;
1648
+ zodClientSchema: import("zod").ZodBoolean;
1649
+ zodValidationSchema: import("zod").ZodBoolean;
1650
+ } & {
1651
+ transforms: {
1652
+ toClient: (dbValue: number) => boolean;
1653
+ toDb: (clientValue: boolean) => number;
1654
+ };
869
1655
  };
870
1656
  };
871
1657
  };