cogsbox-shape 0.5.56 → 0.5.58

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 (6) hide show
  1. package/dist/example/schema.d.ts +434 -3047
  2. package/dist/example/user.d.ts +489 -3102
  3. package/dist/example/user.js +5 -4
  4. package/dist/schema.d.ts +69 -4585
  5. package/dist/schema.js +85 -33
  6. package/package.json +1 -1
package/dist/example/schema.d.ts CHANGED
@@ -1,451 +1,10 @@
1
1
  declare const schemas: {
2
2
  user: {
3
3
  _tableName: string;
4
- id: {
5
- config: {
6
- sql: {
7
- type: "int";
8
- pk: true;
9
- };
10
- zodSqlSchema: import("zod").ZodNumber;
11
- zodNewSchema: import("zod").ZodNumber;
12
- initialValue: number;
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: number;
29
- zodClientSchema: import("zod").ZodNumber;
30
- zodValidationSchema: TValidationNext;
31
- };
32
- transform: (transforms: {
33
- toClient: (dbValue: number) => number;
34
- toDb: (clientValue: number) => number;
35
- }) => {
36
- config: {
37
- sql: {
38
- type: "int";
39
- pk: true;
40
- };
41
- zodSqlSchema: import("zod").ZodNumber;
42
- zodNewSchema: import("zod").ZodNumber;
43
- initialValue: number;
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: {
59
- sql: {
60
- type: "int";
61
- pk: true;
62
- };
63
- zodSqlSchema: import("zod").ZodNumber;
64
- zodNewSchema: import("zod").ZodNumber;
65
- initialValue: number;
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: number;
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: number;
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: number;
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
- };
126
- };
127
- };
128
- };
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: number;
141
- zodClientSchema: import("zod").ZodNumber;
142
- zodValidationSchema: import("zod").ZodNumber;
143
- } & {
144
- transforms: {
145
- toClient: (dbValue: number) => number;
146
- toDb: (clientValue: number) => number;
147
- };
148
- };
149
- };
150
- initialState: {
151
- <TDefaultNext>(defaultValue: () => TDefaultNext): {
152
- config: {
153
- sql: {
154
- type: "int";
155
- pk: true;
156
- };
157
- zodSqlSchema: import("zod").ZodNumber;
158
- zodNewSchema: import("zod").ZodNumber;
159
- initialValue: TDefaultNext;
160
- zodClientSchema: import("zod").ZodNumber;
161
- zodValidationSchema: import("zod").ZodNumber;
162
- };
163
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
164
- sql: import("zod").ZodNumber;
165
- initialState: import("zod").ZodNumber;
166
- client: import("zod").ZodNumber;
167
- }) => TValidationNext)) => {
168
- config: {
169
- sql: {
170
- type: "int";
171
- pk: true;
172
- };
173
- zodSqlSchema: import("zod").ZodNumber;
174
- zodNewSchema: import("zod").ZodNumber;
175
- initialValue: TDefaultNext;
176
- zodClientSchema: import("zod").ZodNumber;
177
- zodValidationSchema: TValidationNext;
178
- };
179
- transform: (transforms: {
180
- toClient: (dbValue: number) => number;
181
- toDb: (clientValue: number) => number;
182
- }) => {
183
- config: {
184
- sql: {
185
- type: "int";
186
- pk: true;
187
- };
188
- zodSqlSchema: import("zod").ZodNumber;
189
- zodNewSchema: import("zod").ZodNumber;
190
- initialValue: TDefaultNext;
191
- zodClientSchema: import("zod").ZodNumber;
192
- zodValidationSchema: TValidationNext;
193
- } & {
194
- transforms: {
195
- toClient: (dbValue: number) => number;
196
- toDb: (clientValue: number) => number;
197
- };
198
- };
199
- };
200
- };
201
- client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
202
- sql: import("zod").ZodNumber;
203
- initialState: import("zod").ZodNumber;
204
- }) => TClientNext)) => {
205
- config: {
206
- sql: {
207
- type: "int";
208
- pk: true;
209
- };
210
- zodSqlSchema: import("zod").ZodNumber;
211
- zodNewSchema: import("zod").ZodNumber;
212
- initialValue: TDefaultNext;
213
- zodClientSchema: TClientNext;
214
- zodValidationSchema: TClientNext;
215
- };
216
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
217
- sql: import("zod").ZodNumber;
218
- initialState: import("zod").ZodNumber;
219
- client: TClientNext;
220
- }) => TValidationNext)) => {
221
- config: {
222
- sql: {
223
- type: "int";
224
- pk: true;
225
- };
226
- zodSqlSchema: import("zod").ZodNumber;
227
- zodNewSchema: import("zod").ZodNumber;
228
- initialValue: TDefaultNext;
229
- zodClientSchema: TClientNext;
230
- zodValidationSchema: TValidationNext;
231
- };
232
- transform: (transforms: {
233
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
234
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
235
- }) => {
236
- config: {
237
- sql: {
238
- type: "int";
239
- pk: true;
240
- };
241
- zodSqlSchema: import("zod").ZodNumber;
242
- zodNewSchema: import("zod").ZodNumber;
243
- initialValue: TDefaultNext;
244
- zodClientSchema: TClientNext;
245
- zodValidationSchema: TValidationNext;
246
- } & {
247
- transforms: {
248
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
249
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
250
- };
251
- };
252
- };
253
- };
254
- transform: (transforms: {
255
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
256
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
257
- }) => {
258
- config: {
259
- sql: {
260
- type: "int";
261
- pk: true;
262
- };
263
- zodSqlSchema: import("zod").ZodNumber;
264
- zodNewSchema: import("zod").ZodNumber;
265
- initialValue: TDefaultNext;
266
- zodClientSchema: TClientNext;
267
- zodValidationSchema: TClientNext;
268
- } & {
269
- transforms: {
270
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
271
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
272
- };
273
- };
274
- };
275
- };
276
- transform: (transforms: {
277
- toClient: (dbValue: number) => number;
278
- toDb: (clientValue: number) => number;
279
- }) => {
280
- config: {
281
- sql: {
282
- type: "int";
283
- pk: true;
284
- };
285
- zodSqlSchema: import("zod").ZodNumber;
286
- zodNewSchema: import("zod").ZodNumber;
287
- initialValue: TDefaultNext;
288
- zodClientSchema: import("zod").ZodNumber;
289
- zodValidationSchema: import("zod").ZodNumber;
290
- } & {
291
- transforms: {
292
- toClient: (dbValue: number) => number;
293
- toDb: (clientValue: number) => number;
294
- };
295
- };
296
- };
297
- };
298
- <TNewNext extends import("zod").ZodTypeAny, TDefaultNext>(schema: TNewNext | ((tools: {
299
- sql: import("zod").ZodNumber;
300
- }) => TNewNext), defaultValue: () => TDefaultNext): {
301
- config: {
302
- sql: {
303
- type: "int";
304
- pk: true;
305
- };
306
- zodSqlSchema: import("zod").ZodNumber;
307
- zodNewSchema: TNewNext;
308
- initialValue: import("zod").TypeOf<TNewNext>;
309
- zodClientSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
310
- zodValidationSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
311
- };
312
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
313
- sql: import("zod").ZodNumber;
314
- initialState: TNewNext;
315
- client: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
316
- }) => TValidationNext)) => {
317
- config: {
318
- sql: {
319
- type: "int";
320
- pk: true;
321
- };
322
- zodSqlSchema: import("zod").ZodNumber;
323
- zodNewSchema: TNewNext;
324
- initialValue: import("zod").TypeOf<TNewNext>;
325
- zodClientSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
326
- zodValidationSchema: TValidationNext;
327
- };
328
- transform: (transforms: {
329
- toClient: (dbValue: number) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>;
330
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>) => number;
331
- }) => {
332
- config: {
333
- sql: {
334
- type: "int";
335
- pk: true;
336
- };
337
- zodSqlSchema: import("zod").ZodNumber;
338
- zodNewSchema: TNewNext;
339
- initialValue: import("zod").TypeOf<TNewNext>;
340
- zodClientSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
341
- zodValidationSchema: TValidationNext;
342
- } & {
343
- transforms: {
344
- toClient: (dbValue: number) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>;
345
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>) => number;
346
- };
347
- };
348
- };
349
- };
350
- client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
351
- sql: import("zod").ZodNumber;
352
- initialState: TNewNext;
353
- }) => TClientNext)) => {
354
- config: {
355
- sql: {
356
- type: "int";
357
- pk: true;
358
- };
359
- zodSqlSchema: import("zod").ZodNumber;
360
- zodNewSchema: TNewNext;
361
- initialValue: import("zod").TypeOf<TNewNext>;
362
- zodClientSchema: TClientNext;
363
- zodValidationSchema: TClientNext;
364
- };
365
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
366
- sql: import("zod").ZodNumber;
367
- initialState: TNewNext;
368
- client: TClientNext;
369
- }) => TValidationNext)) => {
370
- config: {
371
- sql: {
372
- type: "int";
373
- pk: true;
374
- };
375
- zodSqlSchema: import("zod").ZodNumber;
376
- zodNewSchema: TNewNext;
377
- initialValue: import("zod").TypeOf<TNewNext>;
378
- zodClientSchema: TClientNext;
379
- zodValidationSchema: TValidationNext;
380
- };
381
- transform: (transforms: {
382
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
383
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
384
- }) => {
385
- config: {
386
- sql: {
387
- type: "int";
388
- pk: true;
389
- };
390
- zodSqlSchema: import("zod").ZodNumber;
391
- zodNewSchema: TNewNext;
392
- initialValue: import("zod").TypeOf<TNewNext>;
393
- zodClientSchema: TClientNext;
394
- zodValidationSchema: TValidationNext;
395
- } & {
396
- transforms: {
397
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
398
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
399
- };
400
- };
401
- };
402
- };
403
- transform: (transforms: {
404
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
405
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
406
- }) => {
407
- config: {
408
- sql: {
409
- type: "int";
410
- pk: true;
411
- };
412
- zodSqlSchema: import("zod").ZodNumber;
413
- zodNewSchema: TNewNext;
414
- initialValue: import("zod").TypeOf<TNewNext>;
415
- zodClientSchema: TClientNext;
416
- zodValidationSchema: TClientNext;
417
- } & {
418
- transforms: {
419
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
420
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
421
- };
422
- };
423
- };
424
- };
425
- transform: (transforms: {
426
- toClient: (dbValue: number) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>;
427
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>) => number;
428
- }) => {
429
- config: {
430
- sql: {
431
- type: "int";
432
- pk: true;
433
- };
434
- zodSqlSchema: import("zod").ZodNumber;
435
- zodNewSchema: TNewNext;
436
- initialValue: import("zod").TypeOf<TNewNext>;
437
- zodClientSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
438
- zodValidationSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
439
- } & {
440
- transforms: {
441
- toClient: (dbValue: number) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>;
442
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>) => number;
443
- };
444
- };
445
- };
446
- };
447
- };
448
- };
4
+ id: import("..").Builder<"sql", {
5
+ type: "int";
6
+ pk: true;
7
+ }, import("zod").ZodNumber, import("zod").ZodNumber, number, import("zod").ZodNumber, import("zod").ZodNumber>;
449
8
  firstname: {
450
9
  config: {
451
10
  sql: {
@@ -548,504 +107,86 @@ declare const schemas: {
548
107
  };
549
108
  };
550
109
  };
551
- pets: () => {
552
- type: "hasMany";
553
- fromKey: string;
554
- toKey: string | {
555
- config: {
556
- sql: {
557
- type: "int";
558
- pk: true;
559
- };
560
- zodSqlSchema: import("zod").ZodNumber;
561
- zodNewSchema: import("zod").ZodNumber;
562
- initialValue: string;
563
- zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
564
- zodValidationSchema: import("zod").ZodString;
565
- } & {
566
- transforms: {
567
- toClient: (dbValue: number) => number;
568
- toDb: (clientValue: number) => number;
569
- };
570
- };
571
- } | {
572
- config: {
573
- sql: {
574
- type: "varchar";
575
- length: number;
576
- };
577
- zodSqlSchema: import("zod").ZodString;
578
- zodNewSchema: import("zod").ZodString;
579
- initialValue: string;
580
- zodClientSchema: import("zod").ZodString;
581
- zodValidationSchema: import("zod").ZodString;
582
- };
583
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
584
- sql: import("zod").ZodString;
585
- initialState: import("zod").ZodString;
586
- client: import("zod").ZodString;
587
- }) => TValidationNext)) => {
588
- config: {
589
- sql: {
590
- type: "varchar";
591
- length: number;
592
- };
593
- zodSqlSchema: import("zod").ZodString;
594
- zodNewSchema: import("zod").ZodString;
595
- initialValue: string;
596
- zodClientSchema: import("zod").ZodString;
597
- zodValidationSchema: TValidationNext;
598
- };
599
- transform: (transforms: {
600
- toClient: (dbValue: string) => string;
601
- toDb: (clientValue: string) => string;
602
- }) => {
603
- config: {
604
- sql: {
605
- type: "varchar";
606
- length: number;
607
- };
608
- zodSqlSchema: import("zod").ZodString;
609
- zodNewSchema: import("zod").ZodString;
610
- initialValue: string;
611
- zodClientSchema: import("zod").ZodString;
612
- zodValidationSchema: TValidationNext;
613
- } & {
614
- transforms: {
615
- toClient: (dbValue: string) => string;
616
- toDb: (clientValue: string) => string;
110
+ pets: {
111
+ config: {
112
+ sql: ({
113
+ fromKey: string;
114
+ toKey: () => any;
115
+ schema: () => {
116
+ _tableName: string;
117
+ id: {
118
+ config: {
119
+ sql: {
120
+ type: "int";
121
+ pk: true;
122
+ };
123
+ zodSqlSchema: import("zod").ZodNumber;
124
+ zodNewSchema: import("zod").ZodNumber;
125
+ initialValue: string;
126
+ zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
127
+ zodValidationSchema: import("zod").ZodString;
128
+ } & {
129
+ transforms: {
130
+ toClient: (dbValue: number) => number;
131
+ toDb: (clientValue: number) => number;
132
+ };
617
133
  };
618
134
  };
619
- };
620
- };
621
- client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
622
- sql: import("zod").ZodString;
623
- initialState: import("zod").ZodString;
624
- }) => TClientNext)) => {
625
- config: {
626
- sql: {
135
+ name: import("..").Builder<"sql", {
627
136
  type: "varchar";
628
137
  length: number;
138
+ }, import("zod").ZodString, import("zod").ZodString, string, import("zod").ZodString, import("zod").ZodString>;
139
+ userId: {
140
+ type: "reference";
141
+ to: () => import("..").Builder<"sql", {
142
+ type: "int";
143
+ pk: true;
144
+ }, import("zod").ZodNumber, import("zod").ZodNumber, number, import("zod").ZodNumber, import("zod").ZodNumber>;
629
145
  };
630
- zodSqlSchema: import("zod").ZodString;
631
- zodNewSchema: import("zod").ZodString;
632
- initialValue: string;
633
- zodClientSchema: TClientNext;
634
- zodValidationSchema: TClientNext;
635
- };
636
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
637
- sql: import("zod").ZodString;
638
- initialState: import("zod").ZodString;
639
- client: TClientNext;
640
- }) => TValidationNext)) => {
641
- config: {
642
- sql: {
643
- type: "varchar";
644
- length: number;
645
- };
646
- zodSqlSchema: import("zod").ZodString;
647
- zodNewSchema: import("zod").ZodString;
648
- initialValue: string;
649
- zodClientSchema: TClientNext;
650
- zodValidationSchema: TValidationNext;
651
- };
652
- transform: (transforms: {
653
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
654
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
655
- }) => {
146
+ fluffynessScale: {
656
147
  config: {
657
148
  sql: {
658
- type: "varchar";
659
- length: number;
149
+ type: "text";
660
150
  };
661
151
  zodSqlSchema: import("zod").ZodString;
662
152
  zodNewSchema: import("zod").ZodString;
663
153
  initialValue: string;
664
- zodClientSchema: TClientNext;
665
- zodValidationSchema: TValidationNext;
154
+ zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
155
+ zodValidationSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
666
156
  } & {
667
157
  transforms: {
668
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
669
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
158
+ toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
159
+ toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
670
160
  };
671
161
  };
672
162
  };
673
- };
674
- transform: (transforms: {
675
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
676
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
677
- }) => {
678
- config: {
679
- sql: {
680
- type: "varchar";
681
- length: number;
682
- };
683
- zodSqlSchema: import("zod").ZodString;
684
- zodNewSchema: import("zod").ZodString;
685
- initialValue: string;
686
- zodClientSchema: TClientNext;
687
- zodValidationSchema: TClientNext;
688
- } & {
689
- transforms: {
690
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
691
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
692
- };
693
- };
694
- };
695
- };
696
- transform: (transforms: {
697
- toClient: (dbValue: string) => string;
698
- toDb: (clientValue: string) => string;
699
- }) => {
700
- config: {
701
- sql: {
702
- type: "varchar";
703
- length: number;
704
- };
705
- zodSqlSchema: import("zod").ZodString;
706
- zodNewSchema: import("zod").ZodString;
707
- initialValue: string;
708
- zodClientSchema: import("zod").ZodString;
709
- zodValidationSchema: import("zod").ZodString;
710
- } & {
711
- transforms: {
712
- toClient: (dbValue: string) => string;
713
- toDb: (clientValue: string) => string;
714
- };
715
- };
716
- };
717
- initialState: {
718
- <TDefaultNext>(defaultValue: () => TDefaultNext): {
719
- config: {
720
- sql: {
721
- type: "varchar";
722
- length: number;
723
- };
724
- zodSqlSchema: import("zod").ZodString;
725
- zodNewSchema: import("zod").ZodString;
726
- initialValue: TDefaultNext;
727
- zodClientSchema: import("zod").ZodString;
728
- zodValidationSchema: import("zod").ZodString;
729
- };
730
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
731
- sql: import("zod").ZodString;
732
- initialState: import("zod").ZodString;
733
- client: import("zod").ZodString;
734
- }) => TValidationNext)) => {
163
+ favourite: {
735
164
  config: {
736
165
  sql: {
737
- type: "varchar";
738
- length: number;
166
+ type: "int";
739
167
  };
740
- zodSqlSchema: import("zod").ZodString;
741
- zodNewSchema: import("zod").ZodString;
742
- initialValue: TDefaultNext;
743
- zodClientSchema: import("zod").ZodString;
744
- zodValidationSchema: TValidationNext;
745
- };
746
- transform: (transforms: {
747
- toClient: (dbValue: string) => string;
748
- toDb: (clientValue: string) => string;
749
- }) => {
750
- config: {
751
- sql: {
752
- type: "varchar";
753
- length: number;
754
- };
755
- zodSqlSchema: import("zod").ZodString;
756
- zodNewSchema: import("zod").ZodString;
757
- initialValue: TDefaultNext;
758
- zodClientSchema: import("zod").ZodString;
759
- zodValidationSchema: TValidationNext;
760
- } & {
761
- transforms: {
762
- toClient: (dbValue: string) => string;
763
- toDb: (clientValue: string) => string;
764
- };
765
- };
766
- };
767
- };
768
- client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
769
- sql: import("zod").ZodString;
770
- initialState: import("zod").ZodString;
771
- }) => TClientNext)) => {
772
- config: {
773
- sql: {
774
- type: "varchar";
775
- length: number;
776
- };
777
- zodSqlSchema: import("zod").ZodString;
778
- zodNewSchema: import("zod").ZodString;
779
- initialValue: TDefaultNext;
780
- zodClientSchema: TClientNext;
781
- zodValidationSchema: TClientNext;
782
- };
783
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
784
- sql: import("zod").ZodString;
785
- initialState: import("zod").ZodString;
786
- client: TClientNext;
787
- }) => TValidationNext)) => {
788
- config: {
789
- sql: {
790
- type: "varchar";
791
- length: number;
792
- };
793
- zodSqlSchema: import("zod").ZodString;
794
- zodNewSchema: import("zod").ZodString;
795
- initialValue: TDefaultNext;
796
- zodClientSchema: TClientNext;
797
- zodValidationSchema: TValidationNext;
798
- };
799
- transform: (transforms: {
800
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
801
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
802
- }) => {
803
- config: {
804
- sql: {
805
- type: "varchar";
806
- length: number;
807
- };
808
- zodSqlSchema: import("zod").ZodString;
809
- zodNewSchema: import("zod").ZodString;
810
- initialValue: TDefaultNext;
811
- zodClientSchema: TClientNext;
812
- zodValidationSchema: TValidationNext;
813
- } & {
814
- transforms: {
815
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
816
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
817
- };
818
- };
819
- };
820
- };
821
- transform: (transforms: {
822
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
823
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
824
- }) => {
825
- config: {
826
- sql: {
827
- type: "varchar";
828
- length: number;
829
- };
830
- zodSqlSchema: import("zod").ZodString;
831
- zodNewSchema: import("zod").ZodString;
832
- initialValue: TDefaultNext;
833
- zodClientSchema: TClientNext;
834
- zodValidationSchema: TClientNext;
835
- } & {
836
- transforms: {
837
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
838
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
839
- };
840
- };
841
- };
842
- };
843
- transform: (transforms: {
844
- toClient: (dbValue: string) => string;
845
- toDb: (clientValue: string) => string;
846
- }) => {
847
- config: {
848
- sql: {
849
- type: "varchar";
850
- length: number;
851
- };
852
- zodSqlSchema: import("zod").ZodString;
853
- zodNewSchema: import("zod").ZodString;
854
- initialValue: TDefaultNext;
855
- zodClientSchema: import("zod").ZodString;
856
- zodValidationSchema: import("zod").ZodString;
857
- } & {
858
- transforms: {
859
- toClient: (dbValue: string) => string;
860
- toDb: (clientValue: string) => string;
861
- };
862
- };
863
- };
864
- };
865
- <TNewNext extends import("zod").ZodTypeAny, TDefaultNext>(schema: TNewNext | ((tools: {
866
- sql: import("zod").ZodString;
867
- }) => TNewNext), defaultValue: () => TDefaultNext): {
868
- config: {
869
- sql: {
870
- type: "varchar";
871
- length: number;
872
- };
873
- zodSqlSchema: import("zod").ZodString;
874
- zodNewSchema: TNewNext;
875
- initialValue: import("zod").TypeOf<TNewNext>;
876
- zodClientSchema: import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>;
877
- zodValidationSchema: import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>;
878
- };
879
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
880
- sql: import("zod").ZodString;
881
- initialState: TNewNext;
882
- client: import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>;
883
- }) => TValidationNext)) => {
884
- config: {
885
- sql: {
886
- type: "varchar";
887
- length: number;
888
- };
889
- zodSqlSchema: import("zod").ZodString;
890
- zodNewSchema: TNewNext;
891
- initialValue: import("zod").TypeOf<TNewNext>;
892
- zodClientSchema: import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>;
893
- zodValidationSchema: TValidationNext;
894
- };
895
- transform: (transforms: {
896
- toClient: (dbValue: string) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>;
897
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>) => string;
898
- }) => {
899
- config: {
900
- sql: {
901
- type: "varchar";
902
- length: number;
903
- };
904
- zodSqlSchema: import("zod").ZodString;
905
- zodNewSchema: TNewNext;
906
- initialValue: import("zod").TypeOf<TNewNext>;
907
- zodClientSchema: import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>;
908
- zodValidationSchema: TValidationNext;
909
- } & {
910
- transforms: {
911
- toClient: (dbValue: string) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>;
912
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>) => string;
913
- };
914
- };
915
- };
916
- };
917
- client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
918
- sql: import("zod").ZodString;
919
- initialState: TNewNext;
920
- }) => TClientNext)) => {
921
- config: {
922
- sql: {
923
- type: "varchar";
924
- length: number;
925
- };
926
- zodSqlSchema: import("zod").ZodString;
927
- zodNewSchema: TNewNext;
928
- initialValue: import("zod").TypeOf<TNewNext>;
929
- zodClientSchema: TClientNext;
930
- zodValidationSchema: TClientNext;
931
- };
932
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
933
- sql: import("zod").ZodString;
934
- initialState: TNewNext;
935
- client: TClientNext;
936
- }) => TValidationNext)) => {
937
- config: {
938
- sql: {
939
- type: "varchar";
940
- length: number;
941
- };
942
- zodSqlSchema: import("zod").ZodString;
943
- zodNewSchema: TNewNext;
944
- initialValue: import("zod").TypeOf<TNewNext>;
945
- zodClientSchema: TClientNext;
946
- zodValidationSchema: TValidationNext;
947
- };
948
- transform: (transforms: {
949
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
950
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
951
- }) => {
952
- config: {
953
- sql: {
954
- type: "varchar";
955
- length: number;
956
- };
957
- zodSqlSchema: import("zod").ZodString;
958
- zodNewSchema: TNewNext;
959
- initialValue: import("zod").TypeOf<TNewNext>;
960
- zodClientSchema: TClientNext;
961
- zodValidationSchema: TValidationNext;
962
- } & {
963
- transforms: {
964
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
965
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
966
- };
967
- };
968
- };
969
- };
970
- transform: (transforms: {
971
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
972
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
973
- }) => {
974
- config: {
975
- sql: {
976
- type: "varchar";
977
- length: number;
978
- };
979
- zodSqlSchema: import("zod").ZodString;
980
- zodNewSchema: TNewNext;
981
- initialValue: import("zod").TypeOf<TNewNext>;
982
- zodClientSchema: TClientNext;
983
- zodValidationSchema: TClientNext;
984
- } & {
985
- transforms: {
986
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
987
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
988
- };
989
- };
990
- };
991
- };
992
- transform: (transforms: {
993
- toClient: (dbValue: string) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>;
994
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>) => string;
995
- }) => {
996
- config: {
997
- sql: {
998
- type: "varchar";
999
- length: number;
1000
- };
1001
- zodSqlSchema: import("zod").ZodString;
1002
- zodNewSchema: TNewNext;
1003
- initialValue: import("zod").TypeOf<TNewNext>;
1004
- zodClientSchema: import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>;
1005
- zodValidationSchema: import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>;
168
+ zodSqlSchema: import("zod").ZodNumber;
169
+ zodNewSchema: import("zod").ZodNumber;
170
+ initialValue: number;
171
+ zodClientSchema: import("zod").ZodBoolean;
172
+ zodValidationSchema: import("zod").ZodBoolean;
1006
173
  } & {
1007
174
  transforms: {
1008
- toClient: (dbValue: string) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>;
1009
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>) => string;
175
+ toClient: (dbValue: number) => boolean;
176
+ toDb: (clientValue: boolean) => number;
1010
177
  };
1011
178
  };
1012
179
  };
1013
180
  };
1014
- };
1015
- } | {
1016
- type: "reference";
1017
- to: () => {
1018
- config: {
1019
- sql: {
1020
- type: "int";
1021
- pk: true;
1022
- };
1023
- zodSqlSchema: import("zod").ZodNumber;
1024
- zodNewSchema: import("zod").ZodNumber;
1025
- initialValue: number;
1026
- zodClientSchema: import("zod").ZodNumber;
1027
- zodValidationSchema: import("zod").ZodNumber;
1028
- };
1029
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
1030
- sql: import("zod").ZodNumber;
1031
- initialState: import("zod").ZodNumber;
1032
- client: import("zod").ZodNumber;
1033
- }) => TValidationNext)) => {
1034
- config: {
1035
- sql: {
1036
- type: "int";
1037
- pk: true;
1038
- };
1039
- zodSqlSchema: import("zod").ZodNumber;
1040
- zodNewSchema: import("zod").ZodNumber;
1041
- initialValue: number;
1042
- zodClientSchema: import("zod").ZodNumber;
1043
- zodValidationSchema: TValidationNext;
1044
- };
1045
- transform: (transforms: {
1046
- toClient: (dbValue: number) => number;
1047
- toDb: (clientValue: number) => number;
1048
- }) => {
181
+ defaultCount?: number;
182
+ } & {
183
+ type: "hasMany";
184
+ }) | ({
185
+ fromKey: string;
186
+ toKey: () => any;
187
+ schema: () => {
188
+ _tableName: string;
189
+ id: {
1049
190
  config: {
1050
191
  sql: {
1051
192
  type: "int";
@@ -1053,9 +194,9 @@ declare const schemas: {
1053
194
  };
1054
195
  zodSqlSchema: import("zod").ZodNumber;
1055
196
  zodNewSchema: import("zod").ZodNumber;
1056
- initialValue: number;
1057
- zodClientSchema: import("zod").ZodNumber;
1058
- zodValidationSchema: TValidationNext;
197
+ initialValue: string;
198
+ zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
199
+ zodValidationSchema: import("zod").ZodString;
1059
200
  } & {
1060
201
  transforms: {
1061
202
  toClient: (dbValue: number) => number;
@@ -1063,105 +204,61 @@ declare const schemas: {
1063
204
  };
1064
205
  };
1065
206
  };
1066
- };
1067
- client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
1068
- sql: import("zod").ZodNumber;
1069
- initialState: import("zod").ZodNumber;
1070
- }) => TClientNext)) => {
1071
- config: {
1072
- sql: {
207
+ name: import("..").Builder<"sql", {
208
+ type: "varchar";
209
+ length: number;
210
+ }, import("zod").ZodString, import("zod").ZodString, string, import("zod").ZodString, import("zod").ZodString>;
211
+ userId: {
212
+ type: "reference";
213
+ to: () => import("..").Builder<"sql", {
1073
214
  type: "int";
1074
215
  pk: true;
1075
- };
1076
- zodSqlSchema: import("zod").ZodNumber;
1077
- zodNewSchema: import("zod").ZodNumber;
1078
- initialValue: number;
1079
- zodClientSchema: TClientNext;
1080
- zodValidationSchema: TClientNext;
216
+ }, import("zod").ZodNumber, import("zod").ZodNumber, number, import("zod").ZodNumber, import("zod").ZodNumber>;
1081
217
  };
1082
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
1083
- sql: import("zod").ZodNumber;
1084
- initialState: import("zod").ZodNumber;
1085
- client: TClientNext;
1086
- }) => TValidationNext)) => {
218
+ fluffynessScale: {
1087
219
  config: {
1088
220
  sql: {
1089
- type: "int";
1090
- pk: true;
221
+ type: "text";
1091
222
  };
1092
- zodSqlSchema: import("zod").ZodNumber;
1093
- zodNewSchema: import("zod").ZodNumber;
1094
- initialValue: number;
1095
- zodClientSchema: TClientNext;
1096
- zodValidationSchema: TValidationNext;
1097
- };
1098
- transform: (transforms: {
1099
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
1100
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
1101
- }) => {
1102
- config: {
1103
- sql: {
1104
- type: "int";
1105
- pk: true;
1106
- };
1107
- zodSqlSchema: import("zod").ZodNumber;
1108
- zodNewSchema: import("zod").ZodNumber;
1109
- initialValue: number;
1110
- zodClientSchema: TClientNext;
1111
- zodValidationSchema: TValidationNext;
1112
- } & {
1113
- transforms: {
1114
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
1115
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
1116
- };
223
+ zodSqlSchema: import("zod").ZodString;
224
+ zodNewSchema: import("zod").ZodString;
225
+ initialValue: string;
226
+ zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
227
+ zodValidationSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
228
+ } & {
229
+ transforms: {
230
+ toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
231
+ toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
1117
232
  };
1118
233
  };
1119
234
  };
1120
- transform: (transforms: {
1121
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
1122
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
1123
- }) => {
235
+ favourite: {
1124
236
  config: {
1125
237
  sql: {
1126
238
  type: "int";
1127
- pk: true;
1128
239
  };
1129
240
  zodSqlSchema: import("zod").ZodNumber;
1130
241
  zodNewSchema: import("zod").ZodNumber;
1131
242
  initialValue: number;
1132
- zodClientSchema: TClientNext;
1133
- zodValidationSchema: TClientNext;
243
+ zodClientSchema: import("zod").ZodBoolean;
244
+ zodValidationSchema: import("zod").ZodBoolean;
1134
245
  } & {
1135
246
  transforms: {
1136
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
1137
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
247
+ toClient: (dbValue: number) => boolean;
248
+ toDb: (clientValue: boolean) => number;
1138
249
  };
1139
250
  };
1140
251
  };
1141
252
  };
1142
- transform: (transforms: {
1143
- toClient: (dbValue: number) => number;
1144
- toDb: (clientValue: number) => number;
1145
- }) => {
1146
- config: {
1147
- sql: {
1148
- type: "int";
1149
- pk: true;
1150
- };
1151
- zodSqlSchema: import("zod").ZodNumber;
1152
- zodNewSchema: import("zod").ZodNumber;
1153
- initialValue: number;
1154
- zodClientSchema: import("zod").ZodNumber;
1155
- zodValidationSchema: import("zod").ZodNumber;
1156
- } & {
1157
- transforms: {
1158
- toClient: (dbValue: number) => number;
1159
- toDb: (clientValue: number) => number;
1160
- };
1161
- };
1162
- };
1163
- initialState: {
1164
- <TDefaultNext>(defaultValue: () => TDefaultNext): {
253
+ defaultCount?: number;
254
+ } & {
255
+ type: "hasOne";
256
+ }) | ({
257
+ fromKey: string;
258
+ toKey: () => any;
259
+ schema: () => {
260
+ _tableName: string;
261
+ id: {
1165
262
  config: {
1166
263
  sql: {
1167
264
  type: "int";
@@ -1169,1832 +266,71 @@ declare const schemas: {
1169
266
  };
1170
267
  zodSqlSchema: import("zod").ZodNumber;
1171
268
  zodNewSchema: import("zod").ZodNumber;
1172
- initialValue: TDefaultNext;
1173
- zodClientSchema: import("zod").ZodNumber;
1174
- zodValidationSchema: import("zod").ZodNumber;
1175
- };
1176
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
1177
- sql: import("zod").ZodNumber;
1178
- initialState: import("zod").ZodNumber;
1179
- client: import("zod").ZodNumber;
1180
- }) => TValidationNext)) => {
1181
- config: {
1182
- sql: {
1183
- type: "int";
1184
- pk: true;
1185
- };
1186
- zodSqlSchema: import("zod").ZodNumber;
1187
- zodNewSchema: import("zod").ZodNumber;
1188
- initialValue: TDefaultNext;
1189
- zodClientSchema: import("zod").ZodNumber;
1190
- zodValidationSchema: TValidationNext;
1191
- };
1192
- transform: (transforms: {
269
+ initialValue: string;
270
+ zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
271
+ zodValidationSchema: import("zod").ZodString;
272
+ } & {
273
+ transforms: {
1193
274
  toClient: (dbValue: number) => number;
1194
275
  toDb: (clientValue: number) => number;
1195
- }) => {
1196
- config: {
1197
- sql: {
1198
- type: "int";
1199
- pk: true;
1200
- };
1201
- zodSqlSchema: import("zod").ZodNumber;
1202
- zodNewSchema: import("zod").ZodNumber;
1203
- initialValue: TDefaultNext;
1204
- zodClientSchema: import("zod").ZodNumber;
1205
- zodValidationSchema: TValidationNext;
1206
- } & {
1207
- transforms: {
1208
- toClient: (dbValue: number) => number;
1209
- toDb: (clientValue: number) => number;
1210
- };
1211
- };
1212
- };
1213
- };
1214
- client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
1215
- sql: import("zod").ZodNumber;
1216
- initialState: import("zod").ZodNumber;
1217
- }) => TClientNext)) => {
1218
- config: {
1219
- sql: {
1220
- type: "int";
1221
- pk: true;
1222
- };
1223
- zodSqlSchema: import("zod").ZodNumber;
1224
- zodNewSchema: import("zod").ZodNumber;
1225
- initialValue: TDefaultNext;
1226
- zodClientSchema: TClientNext;
1227
- zodValidationSchema: TClientNext;
1228
- };
1229
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
1230
- sql: import("zod").ZodNumber;
1231
- initialState: import("zod").ZodNumber;
1232
- client: TClientNext;
1233
- }) => TValidationNext)) => {
1234
- config: {
1235
- sql: {
1236
- type: "int";
1237
- pk: true;
1238
- };
1239
- zodSqlSchema: import("zod").ZodNumber;
1240
- zodNewSchema: import("zod").ZodNumber;
1241
- initialValue: TDefaultNext;
1242
- zodClientSchema: TClientNext;
1243
- zodValidationSchema: TValidationNext;
1244
- };
1245
- transform: (transforms: {
1246
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
1247
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
1248
- }) => {
1249
- config: {
1250
- sql: {
1251
- type: "int";
1252
- pk: true;
1253
- };
1254
- zodSqlSchema: import("zod").ZodNumber;
1255
- zodNewSchema: import("zod").ZodNumber;
1256
- initialValue: TDefaultNext;
1257
- zodClientSchema: TClientNext;
1258
- zodValidationSchema: TValidationNext;
1259
- } & {
1260
- transforms: {
1261
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
1262
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
1263
- };
1264
- };
1265
- };
1266
- };
1267
- transform: (transforms: {
1268
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
1269
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
1270
- }) => {
1271
- config: {
1272
- sql: {
1273
- type: "int";
1274
- pk: true;
1275
- };
1276
- zodSqlSchema: import("zod").ZodNumber;
1277
- zodNewSchema: import("zod").ZodNumber;
1278
- initialValue: TDefaultNext;
1279
- zodClientSchema: TClientNext;
1280
- zodValidationSchema: TClientNext;
1281
- } & {
1282
- transforms: {
1283
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
1284
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
1285
- };
1286
- };
1287
- };
1288
- };
1289
- transform: (transforms: {
1290
- toClient: (dbValue: number) => number;
1291
- toDb: (clientValue: number) => number;
1292
- }) => {
1293
- config: {
1294
- sql: {
1295
- type: "int";
1296
- pk: true;
1297
- };
1298
- zodSqlSchema: import("zod").ZodNumber;
1299
- zodNewSchema: import("zod").ZodNumber;
1300
- initialValue: TDefaultNext;
1301
- zodClientSchema: import("zod").ZodNumber;
1302
- zodValidationSchema: import("zod").ZodNumber;
1303
- } & {
1304
- transforms: {
1305
- toClient: (dbValue: number) => number;
1306
- toDb: (clientValue: number) => number;
1307
- };
1308
- };
1309
- };
1310
- };
1311
- <TNewNext extends import("zod").ZodTypeAny, TDefaultNext>(schema: TNewNext | ((tools: {
1312
- sql: import("zod").ZodNumber;
1313
- }) => TNewNext), defaultValue: () => TDefaultNext): {
1314
- config: {
1315
- sql: {
1316
- type: "int";
1317
- pk: true;
1318
- };
1319
- zodSqlSchema: import("zod").ZodNumber;
1320
- zodNewSchema: TNewNext;
1321
- initialValue: import("zod").TypeOf<TNewNext>;
1322
- zodClientSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
1323
- zodValidationSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
1324
- };
1325
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
1326
- sql: import("zod").ZodNumber;
1327
- initialState: TNewNext;
1328
- client: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
1329
- }) => TValidationNext)) => {
1330
- config: {
1331
- sql: {
1332
- type: "int";
1333
- pk: true;
1334
- };
1335
- zodSqlSchema: import("zod").ZodNumber;
1336
- zodNewSchema: TNewNext;
1337
- initialValue: import("zod").TypeOf<TNewNext>;
1338
- zodClientSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
1339
- zodValidationSchema: TValidationNext;
1340
- };
1341
- transform: (transforms: {
1342
- toClient: (dbValue: number) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>;
1343
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>) => number;
1344
- }) => {
1345
- config: {
1346
- sql: {
1347
- type: "int";
1348
- pk: true;
1349
- };
1350
- zodSqlSchema: import("zod").ZodNumber;
1351
- zodNewSchema: TNewNext;
1352
- initialValue: import("zod").TypeOf<TNewNext>;
1353
- zodClientSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
1354
- zodValidationSchema: TValidationNext;
1355
- } & {
1356
- transforms: {
1357
- toClient: (dbValue: number) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>;
1358
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>) => number;
1359
- };
1360
- };
1361
- };
1362
- };
1363
- client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
1364
- sql: import("zod").ZodNumber;
1365
- initialState: TNewNext;
1366
- }) => TClientNext)) => {
1367
- config: {
1368
- sql: {
1369
- type: "int";
1370
- pk: true;
1371
- };
1372
- zodSqlSchema: import("zod").ZodNumber;
1373
- zodNewSchema: TNewNext;
1374
- initialValue: import("zod").TypeOf<TNewNext>;
1375
- zodClientSchema: TClientNext;
1376
- zodValidationSchema: TClientNext;
1377
- };
1378
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
1379
- sql: import("zod").ZodNumber;
1380
- initialState: TNewNext;
1381
- client: TClientNext;
1382
- }) => TValidationNext)) => {
1383
- config: {
1384
- sql: {
1385
- type: "int";
1386
- pk: true;
1387
- };
1388
- zodSqlSchema: import("zod").ZodNumber;
1389
- zodNewSchema: TNewNext;
1390
- initialValue: import("zod").TypeOf<TNewNext>;
1391
- zodClientSchema: TClientNext;
1392
- zodValidationSchema: TValidationNext;
1393
- };
1394
- transform: (transforms: {
1395
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
1396
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
1397
- }) => {
1398
- config: {
1399
- sql: {
1400
- type: "int";
1401
- pk: true;
1402
- };
1403
- zodSqlSchema: import("zod").ZodNumber;
1404
- zodNewSchema: TNewNext;
1405
- initialValue: import("zod").TypeOf<TNewNext>;
1406
- zodClientSchema: TClientNext;
1407
- zodValidationSchema: TValidationNext;
1408
- } & {
1409
- transforms: {
1410
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
1411
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
1412
- };
1413
- };
1414
- };
1415
- };
1416
- transform: (transforms: {
1417
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
1418
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
1419
- }) => {
1420
- config: {
1421
- sql: {
1422
- type: "int";
1423
- pk: true;
1424
- };
1425
- zodSqlSchema: import("zod").ZodNumber;
1426
- zodNewSchema: TNewNext;
1427
- initialValue: import("zod").TypeOf<TNewNext>;
1428
- zodClientSchema: TClientNext;
1429
- zodValidationSchema: TClientNext;
1430
- } & {
1431
- transforms: {
1432
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
1433
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
1434
- };
1435
- };
1436
- };
1437
- };
1438
- transform: (transforms: {
1439
- toClient: (dbValue: number) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>;
1440
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>) => number;
1441
- }) => {
1442
- config: {
1443
- sql: {
1444
- type: "int";
1445
- pk: true;
1446
- };
1447
- zodSqlSchema: import("zod").ZodNumber;
1448
- zodNewSchema: TNewNext;
1449
- initialValue: import("zod").TypeOf<TNewNext>;
1450
- zodClientSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
1451
- zodValidationSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
1452
- } & {
1453
- transforms: {
1454
- toClient: (dbValue: number) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>;
1455
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>) => number;
1456
- };
1457
276
  };
1458
277
  };
1459
278
  };
1460
- };
1461
- };
1462
- } | {
1463
- config: {
1464
- sql: {
1465
- type: "text";
1466
- };
1467
- zodSqlSchema: import("zod").ZodString;
1468
- zodNewSchema: import("zod").ZodString;
1469
- initialValue: string;
1470
- zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
1471
- zodValidationSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
1472
- } & {
1473
- transforms: {
1474
- toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
1475
- toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
1476
- };
1477
- };
1478
- } | {
1479
- config: {
1480
- sql: {
1481
- type: "int";
1482
- };
1483
- zodSqlSchema: import("zod").ZodNumber;
1484
- zodNewSchema: import("zod").ZodNumber;
1485
- initialValue: number;
1486
- zodClientSchema: import("zod").ZodBoolean;
1487
- zodValidationSchema: import("zod").ZodBoolean;
1488
- } & {
1489
- transforms: {
1490
- toClient: (dbValue: number) => boolean;
1491
- toDb: (clientValue: boolean) => number;
1492
- };
1493
- };
1494
- };
1495
- schema: {
1496
- _tableName: string;
1497
- id: {
1498
- config: {
1499
- sql: {
1500
- type: "int";
1501
- pk: true;
1502
- };
1503
- zodSqlSchema: import("zod").ZodNumber;
1504
- zodNewSchema: import("zod").ZodNumber;
1505
- initialValue: string;
1506
- zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
1507
- zodValidationSchema: import("zod").ZodString;
1508
- } & {
1509
- transforms: {
1510
- toClient: (dbValue: number) => number;
1511
- toDb: (clientValue: number) => number;
1512
- };
1513
- };
1514
- };
1515
- name: {
1516
- config: {
1517
- sql: {
279
+ name: import("..").Builder<"sql", {
1518
280
  type: "varchar";
1519
281
  length: number;
1520
- };
1521
- zodSqlSchema: import("zod").ZodString;
1522
- zodNewSchema: import("zod").ZodString;
1523
- initialValue: string;
1524
- zodClientSchema: import("zod").ZodString;
1525
- zodValidationSchema: import("zod").ZodString;
1526
- };
1527
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
1528
- sql: import("zod").ZodString;
1529
- initialState: import("zod").ZodString;
1530
- client: import("zod").ZodString;
1531
- }) => TValidationNext)) => {
1532
- config: {
1533
- sql: {
1534
- type: "varchar";
1535
- length: number;
1536
- };
1537
- zodSqlSchema: import("zod").ZodString;
1538
- zodNewSchema: import("zod").ZodString;
1539
- initialValue: string;
1540
- zodClientSchema: import("zod").ZodString;
1541
- zodValidationSchema: TValidationNext;
1542
- };
1543
- transform: (transforms: {
1544
- toClient: (dbValue: string) => string;
1545
- toDb: (clientValue: string) => string;
1546
- }) => {
1547
- config: {
1548
- sql: {
1549
- type: "varchar";
1550
- length: number;
1551
- };
1552
- zodSqlSchema: import("zod").ZodString;
1553
- zodNewSchema: import("zod").ZodString;
1554
- initialValue: string;
1555
- zodClientSchema: import("zod").ZodString;
1556
- zodValidationSchema: TValidationNext;
1557
- } & {
1558
- transforms: {
1559
- toClient: (dbValue: string) => string;
1560
- toDb: (clientValue: string) => string;
1561
- };
1562
- };
1563
- };
1564
- };
1565
- client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
1566
- sql: import("zod").ZodString;
1567
- initialState: import("zod").ZodString;
1568
- }) => TClientNext)) => {
1569
- config: {
1570
- sql: {
1571
- type: "varchar";
1572
- length: number;
1573
- };
1574
- zodSqlSchema: import("zod").ZodString;
1575
- zodNewSchema: import("zod").ZodString;
1576
- initialValue: string;
1577
- zodClientSchema: TClientNext;
1578
- zodValidationSchema: TClientNext;
1579
- };
1580
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
1581
- sql: import("zod").ZodString;
1582
- initialState: import("zod").ZodString;
1583
- client: TClientNext;
1584
- }) => TValidationNext)) => {
1585
- config: {
1586
- sql: {
1587
- type: "varchar";
1588
- length: number;
1589
- };
1590
- zodSqlSchema: import("zod").ZodString;
1591
- zodNewSchema: import("zod").ZodString;
1592
- initialValue: string;
1593
- zodClientSchema: TClientNext;
1594
- zodValidationSchema: TValidationNext;
1595
- };
1596
- transform: (transforms: {
1597
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1598
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1599
- }) => {
1600
- config: {
1601
- sql: {
1602
- type: "varchar";
1603
- length: number;
1604
- };
1605
- zodSqlSchema: import("zod").ZodString;
1606
- zodNewSchema: import("zod").ZodString;
1607
- initialValue: string;
1608
- zodClientSchema: TClientNext;
1609
- zodValidationSchema: TValidationNext;
1610
- } & {
1611
- transforms: {
1612
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1613
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1614
- };
1615
- };
1616
- };
1617
- };
1618
- transform: (transforms: {
1619
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1620
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1621
- }) => {
1622
- config: {
1623
- sql: {
1624
- type: "varchar";
1625
- length: number;
1626
- };
1627
- zodSqlSchema: import("zod").ZodString;
1628
- zodNewSchema: import("zod").ZodString;
1629
- initialValue: string;
1630
- zodClientSchema: TClientNext;
1631
- zodValidationSchema: TClientNext;
1632
- } & {
1633
- transforms: {
1634
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1635
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1636
- };
1637
- };
1638
- };
1639
- };
1640
- transform: (transforms: {
1641
- toClient: (dbValue: string) => string;
1642
- toDb: (clientValue: string) => string;
1643
- }) => {
1644
- config: {
1645
- sql: {
1646
- type: "varchar";
1647
- length: number;
1648
- };
1649
- zodSqlSchema: import("zod").ZodString;
1650
- zodNewSchema: import("zod").ZodString;
1651
- initialValue: string;
1652
- zodClientSchema: import("zod").ZodString;
1653
- zodValidationSchema: import("zod").ZodString;
1654
- } & {
1655
- transforms: {
1656
- toClient: (dbValue: string) => string;
1657
- toDb: (clientValue: string) => string;
1658
- };
1659
- };
1660
- };
1661
- initialState: {
1662
- <TDefaultNext>(defaultValue: () => TDefaultNext): {
1663
- config: {
1664
- sql: {
1665
- type: "varchar";
1666
- length: number;
1667
- };
1668
- zodSqlSchema: import("zod").ZodString;
1669
- zodNewSchema: import("zod").ZodString;
1670
- initialValue: TDefaultNext;
1671
- zodClientSchema: import("zod").ZodString;
1672
- zodValidationSchema: import("zod").ZodString;
1673
- };
1674
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
1675
- sql: import("zod").ZodString;
1676
- initialState: import("zod").ZodString;
1677
- client: import("zod").ZodString;
1678
- }) => TValidationNext)) => {
1679
- config: {
1680
- sql: {
1681
- type: "varchar";
1682
- length: number;
1683
- };
1684
- zodSqlSchema: import("zod").ZodString;
1685
- zodNewSchema: import("zod").ZodString;
1686
- initialValue: TDefaultNext;
1687
- zodClientSchema: import("zod").ZodString;
1688
- zodValidationSchema: TValidationNext;
1689
- };
1690
- transform: (transforms: {
1691
- toClient: (dbValue: string) => string;
1692
- toDb: (clientValue: string) => string;
1693
- }) => {
1694
- config: {
1695
- sql: {
1696
- type: "varchar";
1697
- length: number;
1698
- };
1699
- zodSqlSchema: import("zod").ZodString;
1700
- zodNewSchema: import("zod").ZodString;
1701
- initialValue: TDefaultNext;
1702
- zodClientSchema: import("zod").ZodString;
1703
- zodValidationSchema: TValidationNext;
1704
- } & {
1705
- transforms: {
1706
- toClient: (dbValue: string) => string;
1707
- toDb: (clientValue: string) => string;
1708
- };
1709
- };
1710
- };
1711
- };
1712
- client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
1713
- sql: import("zod").ZodString;
1714
- initialState: import("zod").ZodString;
1715
- }) => TClientNext)) => {
1716
- config: {
1717
- sql: {
1718
- type: "varchar";
1719
- length: number;
1720
- };
1721
- zodSqlSchema: import("zod").ZodString;
1722
- zodNewSchema: import("zod").ZodString;
1723
- initialValue: TDefaultNext;
1724
- zodClientSchema: TClientNext;
1725
- zodValidationSchema: TClientNext;
1726
- };
1727
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
1728
- sql: import("zod").ZodString;
1729
- initialState: import("zod").ZodString;
1730
- client: TClientNext;
1731
- }) => TValidationNext)) => {
1732
- config: {
1733
- sql: {
1734
- type: "varchar";
1735
- length: number;
1736
- };
1737
- zodSqlSchema: import("zod").ZodString;
1738
- zodNewSchema: import("zod").ZodString;
1739
- initialValue: TDefaultNext;
1740
- zodClientSchema: TClientNext;
1741
- zodValidationSchema: TValidationNext;
1742
- };
1743
- transform: (transforms: {
1744
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1745
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1746
- }) => {
1747
- config: {
1748
- sql: {
1749
- type: "varchar";
1750
- length: number;
1751
- };
1752
- zodSqlSchema: import("zod").ZodString;
1753
- zodNewSchema: import("zod").ZodString;
1754
- initialValue: TDefaultNext;
1755
- zodClientSchema: TClientNext;
1756
- zodValidationSchema: TValidationNext;
1757
- } & {
1758
- transforms: {
1759
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1760
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1761
- };
1762
- };
1763
- };
1764
- };
1765
- transform: (transforms: {
1766
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1767
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1768
- }) => {
1769
- config: {
1770
- sql: {
1771
- type: "varchar";
1772
- length: number;
1773
- };
1774
- zodSqlSchema: import("zod").ZodString;
1775
- zodNewSchema: import("zod").ZodString;
1776
- initialValue: TDefaultNext;
1777
- zodClientSchema: TClientNext;
1778
- zodValidationSchema: TClientNext;
1779
- } & {
1780
- transforms: {
1781
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1782
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1783
- };
1784
- };
1785
- };
1786
- };
1787
- transform: (transforms: {
1788
- toClient: (dbValue: string) => string;
1789
- toDb: (clientValue: string) => string;
1790
- }) => {
1791
- config: {
1792
- sql: {
1793
- type: "varchar";
1794
- length: number;
1795
- };
1796
- zodSqlSchema: import("zod").ZodString;
1797
- zodNewSchema: import("zod").ZodString;
1798
- initialValue: TDefaultNext;
1799
- zodClientSchema: import("zod").ZodString;
1800
- zodValidationSchema: import("zod").ZodString;
1801
- } & {
1802
- transforms: {
1803
- toClient: (dbValue: string) => string;
1804
- toDb: (clientValue: string) => string;
1805
- };
1806
- };
1807
- };
1808
- };
1809
- <TNewNext extends import("zod").ZodTypeAny, TDefaultNext>(schema: TNewNext | ((tools: {
1810
- sql: import("zod").ZodString;
1811
- }) => TNewNext), defaultValue: () => TDefaultNext): {
1812
- config: {
1813
- sql: {
1814
- type: "varchar";
1815
- length: number;
1816
- };
1817
- zodSqlSchema: import("zod").ZodString;
1818
- zodNewSchema: TNewNext;
1819
- initialValue: import("zod").TypeOf<TNewNext>;
1820
- zodClientSchema: import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>;
1821
- zodValidationSchema: import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>;
1822
- };
1823
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
1824
- sql: import("zod").ZodString;
1825
- initialState: TNewNext;
1826
- client: import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>;
1827
- }) => TValidationNext)) => {
1828
- config: {
1829
- sql: {
1830
- type: "varchar";
1831
- length: number;
1832
- };
1833
- zodSqlSchema: import("zod").ZodString;
1834
- zodNewSchema: TNewNext;
1835
- initialValue: import("zod").TypeOf<TNewNext>;
1836
- zodClientSchema: import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>;
1837
- zodValidationSchema: TValidationNext;
1838
- };
1839
- transform: (transforms: {
1840
- toClient: (dbValue: string) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>;
1841
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>) => string;
1842
- }) => {
1843
- config: {
1844
- sql: {
1845
- type: "varchar";
1846
- length: number;
1847
- };
1848
- zodSqlSchema: import("zod").ZodString;
1849
- zodNewSchema: TNewNext;
1850
- initialValue: import("zod").TypeOf<TNewNext>;
1851
- zodClientSchema: import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>;
1852
- zodValidationSchema: TValidationNext;
1853
- } & {
1854
- transforms: {
1855
- toClient: (dbValue: string) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>;
1856
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>) => string;
1857
- };
1858
- };
1859
- };
1860
- };
1861
- client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
1862
- sql: import("zod").ZodString;
1863
- initialState: TNewNext;
1864
- }) => TClientNext)) => {
1865
- config: {
1866
- sql: {
1867
- type: "varchar";
1868
- length: number;
1869
- };
1870
- zodSqlSchema: import("zod").ZodString;
1871
- zodNewSchema: TNewNext;
1872
- initialValue: import("zod").TypeOf<TNewNext>;
1873
- zodClientSchema: TClientNext;
1874
- zodValidationSchema: TClientNext;
1875
- };
1876
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
1877
- sql: import("zod").ZodString;
1878
- initialState: TNewNext;
1879
- client: TClientNext;
1880
- }) => TValidationNext)) => {
1881
- config: {
1882
- sql: {
1883
- type: "varchar";
1884
- length: number;
1885
- };
1886
- zodSqlSchema: import("zod").ZodString;
1887
- zodNewSchema: TNewNext;
1888
- initialValue: import("zod").TypeOf<TNewNext>;
1889
- zodClientSchema: TClientNext;
1890
- zodValidationSchema: TValidationNext;
1891
- };
1892
- transform: (transforms: {
1893
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1894
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1895
- }) => {
1896
- config: {
1897
- sql: {
1898
- type: "varchar";
1899
- length: number;
1900
- };
1901
- zodSqlSchema: import("zod").ZodString;
1902
- zodNewSchema: TNewNext;
1903
- initialValue: import("zod").TypeOf<TNewNext>;
1904
- zodClientSchema: TClientNext;
1905
- zodValidationSchema: TValidationNext;
1906
- } & {
1907
- transforms: {
1908
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1909
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1910
- };
1911
- };
1912
- };
1913
- };
1914
- transform: (transforms: {
1915
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1916
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1917
- }) => {
1918
- config: {
1919
- sql: {
1920
- type: "varchar";
1921
- length: number;
1922
- };
1923
- zodSqlSchema: import("zod").ZodString;
1924
- zodNewSchema: TNewNext;
1925
- initialValue: import("zod").TypeOf<TNewNext>;
1926
- zodClientSchema: TClientNext;
1927
- zodValidationSchema: TClientNext;
1928
- } & {
1929
- transforms: {
1930
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
1931
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
1932
- };
1933
- };
1934
- };
1935
- };
1936
- transform: (transforms: {
1937
- toClient: (dbValue: string) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>;
1938
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>) => string;
1939
- }) => {
1940
- config: {
1941
- sql: {
1942
- type: "varchar";
1943
- length: number;
1944
- };
1945
- zodSqlSchema: import("zod").ZodString;
1946
- zodNewSchema: TNewNext;
1947
- initialValue: import("zod").TypeOf<TNewNext>;
1948
- zodClientSchema: import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>;
1949
- zodValidationSchema: import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>;
1950
- } & {
1951
- transforms: {
1952
- toClient: (dbValue: string) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>;
1953
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>) => string;
1954
- };
1955
- };
1956
- };
1957
- };
1958
- };
1959
- };
1960
- userId: {
1961
- type: "reference";
1962
- to: () => {
1963
- config: {
1964
- sql: {
282
+ }, import("zod").ZodString, import("zod").ZodString, string, import("zod").ZodString, import("zod").ZodString>;
283
+ userId: {
284
+ type: "reference";
285
+ to: () => import("..").Builder<"sql", {
1965
286
  type: "int";
1966
- pk: true;
1967
- };
1968
- zodSqlSchema: import("zod").ZodNumber;
1969
- zodNewSchema: import("zod").ZodNumber;
1970
- initialValue: number;
1971
- zodClientSchema: import("zod").ZodNumber;
1972
- zodValidationSchema: import("zod").ZodNumber;
1973
- };
1974
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
1975
- sql: import("zod").ZodNumber;
1976
- initialState: import("zod").ZodNumber;
1977
- client: import("zod").ZodNumber;
1978
- }) => TValidationNext)) => {
1979
- config: {
1980
- sql: {
1981
- type: "int";
1982
- pk: true;
1983
- };
1984
- zodSqlSchema: import("zod").ZodNumber;
1985
- zodNewSchema: import("zod").ZodNumber;
1986
- initialValue: number;
1987
- zodClientSchema: import("zod").ZodNumber;
1988
- zodValidationSchema: TValidationNext;
1989
- };
1990
- transform: (transforms: {
1991
- toClient: (dbValue: number) => number;
1992
- toDb: (clientValue: number) => number;
1993
- }) => {
1994
- config: {
1995
- sql: {
1996
- type: "int";
1997
- pk: true;
1998
- };
1999
- zodSqlSchema: import("zod").ZodNumber;
2000
- zodNewSchema: import("zod").ZodNumber;
2001
- initialValue: number;
2002
- zodClientSchema: import("zod").ZodNumber;
2003
- zodValidationSchema: TValidationNext;
2004
- } & {
2005
- transforms: {
2006
- toClient: (dbValue: number) => number;
2007
- toDb: (clientValue: number) => number;
2008
- };
2009
- };
2010
- };
2011
- };
2012
- client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
2013
- sql: import("zod").ZodNumber;
2014
- initialState: import("zod").ZodNumber;
2015
- }) => TClientNext)) => {
2016
- config: {
2017
- sql: {
2018
- type: "int";
2019
- pk: true;
2020
- };
2021
- zodSqlSchema: import("zod").ZodNumber;
2022
- zodNewSchema: import("zod").ZodNumber;
2023
- initialValue: number;
2024
- zodClientSchema: TClientNext;
2025
- zodValidationSchema: TClientNext;
2026
- };
2027
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
2028
- sql: import("zod").ZodNumber;
2029
- initialState: import("zod").ZodNumber;
2030
- client: TClientNext;
2031
- }) => TValidationNext)) => {
2032
- config: {
2033
- sql: {
2034
- type: "int";
2035
- pk: true;
2036
- };
2037
- zodSqlSchema: import("zod").ZodNumber;
2038
- zodNewSchema: import("zod").ZodNumber;
2039
- initialValue: number;
2040
- zodClientSchema: TClientNext;
2041
- zodValidationSchema: TValidationNext;
2042
- };
2043
- transform: (transforms: {
2044
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
2045
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
2046
- }) => {
2047
- config: {
2048
- sql: {
2049
- type: "int";
2050
- pk: true;
2051
- };
2052
- zodSqlSchema: import("zod").ZodNumber;
2053
- zodNewSchema: import("zod").ZodNumber;
2054
- initialValue: number;
2055
- zodClientSchema: TClientNext;
2056
- zodValidationSchema: TValidationNext;
2057
- } & {
2058
- transforms: {
2059
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
2060
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
2061
- };
2062
- };
2063
- };
2064
- };
2065
- transform: (transforms: {
2066
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
2067
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
2068
- }) => {
2069
- config: {
2070
- sql: {
2071
- type: "int";
2072
- pk: true;
2073
- };
2074
- zodSqlSchema: import("zod").ZodNumber;
2075
- zodNewSchema: import("zod").ZodNumber;
2076
- initialValue: number;
2077
- zodClientSchema: TClientNext;
2078
- zodValidationSchema: TClientNext;
2079
- } & {
2080
- transforms: {
2081
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
2082
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
2083
- };
2084
- };
2085
- };
2086
- };
2087
- transform: (transforms: {
2088
- toClient: (dbValue: number) => number;
2089
- toDb: (clientValue: number) => number;
2090
- }) => {
2091
- config: {
2092
- sql: {
2093
- type: "int";
2094
- pk: true;
2095
- };
2096
- zodSqlSchema: import("zod").ZodNumber;
2097
- zodNewSchema: import("zod").ZodNumber;
2098
- initialValue: number;
2099
- zodClientSchema: import("zod").ZodNumber;
2100
- zodValidationSchema: import("zod").ZodNumber;
2101
- } & {
2102
- transforms: {
2103
- toClient: (dbValue: number) => number;
2104
- toDb: (clientValue: number) => number;
2105
- };
2106
- };
2107
- };
2108
- initialState: {
2109
- <TDefaultNext>(defaultValue: () => TDefaultNext): {
2110
- config: {
2111
- sql: {
2112
- type: "int";
2113
- pk: true;
2114
- };
2115
- zodSqlSchema: import("zod").ZodNumber;
2116
- zodNewSchema: import("zod").ZodNumber;
2117
- initialValue: TDefaultNext;
2118
- zodClientSchema: import("zod").ZodNumber;
2119
- zodValidationSchema: import("zod").ZodNumber;
2120
- };
2121
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
2122
- sql: import("zod").ZodNumber;
2123
- initialState: import("zod").ZodNumber;
2124
- client: import("zod").ZodNumber;
2125
- }) => TValidationNext)) => {
2126
- config: {
2127
- sql: {
2128
- type: "int";
2129
- pk: true;
2130
- };
2131
- zodSqlSchema: import("zod").ZodNumber;
2132
- zodNewSchema: import("zod").ZodNumber;
2133
- initialValue: TDefaultNext;
2134
- zodClientSchema: import("zod").ZodNumber;
2135
- zodValidationSchema: TValidationNext;
2136
- };
2137
- transform: (transforms: {
2138
- toClient: (dbValue: number) => number;
2139
- toDb: (clientValue: number) => number;
2140
- }) => {
2141
- config: {
2142
- sql: {
2143
- type: "int";
2144
- pk: true;
2145
- };
2146
- zodSqlSchema: import("zod").ZodNumber;
2147
- zodNewSchema: import("zod").ZodNumber;
2148
- initialValue: TDefaultNext;
2149
- zodClientSchema: import("zod").ZodNumber;
2150
- zodValidationSchema: TValidationNext;
2151
- } & {
2152
- transforms: {
2153
- toClient: (dbValue: number) => number;
2154
- toDb: (clientValue: number) => number;
2155
- };
2156
- };
2157
- };
2158
- };
2159
- client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
2160
- sql: import("zod").ZodNumber;
2161
- initialState: import("zod").ZodNumber;
2162
- }) => TClientNext)) => {
2163
- config: {
2164
- sql: {
2165
- type: "int";
2166
- pk: true;
2167
- };
2168
- zodSqlSchema: import("zod").ZodNumber;
2169
- zodNewSchema: import("zod").ZodNumber;
2170
- initialValue: TDefaultNext;
2171
- zodClientSchema: TClientNext;
2172
- zodValidationSchema: TClientNext;
2173
- };
2174
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
2175
- sql: import("zod").ZodNumber;
2176
- initialState: import("zod").ZodNumber;
2177
- client: TClientNext;
2178
- }) => TValidationNext)) => {
2179
- config: {
2180
- sql: {
2181
- type: "int";
2182
- pk: true;
2183
- };
2184
- zodSqlSchema: import("zod").ZodNumber;
2185
- zodNewSchema: import("zod").ZodNumber;
2186
- initialValue: TDefaultNext;
2187
- zodClientSchema: TClientNext;
2188
- zodValidationSchema: TValidationNext;
2189
- };
2190
- transform: (transforms: {
2191
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
2192
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
2193
- }) => {
2194
- config: {
2195
- sql: {
2196
- type: "int";
2197
- pk: true;
2198
- };
2199
- zodSqlSchema: import("zod").ZodNumber;
2200
- zodNewSchema: import("zod").ZodNumber;
2201
- initialValue: TDefaultNext;
2202
- zodClientSchema: TClientNext;
2203
- zodValidationSchema: TValidationNext;
2204
- } & {
2205
- transforms: {
2206
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
2207
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
2208
- };
2209
- };
2210
- };
2211
- };
2212
- transform: (transforms: {
2213
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
2214
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
2215
- }) => {
2216
- config: {
2217
- sql: {
2218
- type: "int";
2219
- pk: true;
2220
- };
2221
- zodSqlSchema: import("zod").ZodNumber;
2222
- zodNewSchema: import("zod").ZodNumber;
2223
- initialValue: TDefaultNext;
2224
- zodClientSchema: TClientNext;
2225
- zodValidationSchema: TClientNext;
2226
- } & {
2227
- transforms: {
2228
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
2229
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
2230
- };
2231
- };
2232
- };
2233
- };
2234
- transform: (transforms: {
2235
- toClient: (dbValue: number) => number;
2236
- toDb: (clientValue: number) => number;
2237
- }) => {
2238
- config: {
2239
- sql: {
2240
- type: "int";
2241
- pk: true;
2242
- };
2243
- zodSqlSchema: import("zod").ZodNumber;
2244
- zodNewSchema: import("zod").ZodNumber;
2245
- initialValue: TDefaultNext;
2246
- zodClientSchema: import("zod").ZodNumber;
2247
- zodValidationSchema: import("zod").ZodNumber;
2248
- } & {
2249
- transforms: {
2250
- toClient: (dbValue: number) => number;
2251
- toDb: (clientValue: number) => number;
2252
- };
2253
- };
2254
- };
2255
- };
2256
- <TNewNext extends import("zod").ZodTypeAny, TDefaultNext>(schema: TNewNext | ((tools: {
2257
- sql: import("zod").ZodNumber;
2258
- }) => TNewNext), defaultValue: () => TDefaultNext): {
2259
- config: {
2260
- sql: {
2261
- type: "int";
2262
- pk: true;
2263
- };
2264
- zodSqlSchema: import("zod").ZodNumber;
2265
- zodNewSchema: TNewNext;
2266
- initialValue: import("zod").TypeOf<TNewNext>;
2267
- zodClientSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
2268
- zodValidationSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
2269
- };
2270
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
2271
- sql: import("zod").ZodNumber;
2272
- initialState: TNewNext;
2273
- client: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
2274
- }) => TValidationNext)) => {
2275
- config: {
2276
- sql: {
2277
- type: "int";
2278
- pk: true;
2279
- };
2280
- zodSqlSchema: import("zod").ZodNumber;
2281
- zodNewSchema: TNewNext;
2282
- initialValue: import("zod").TypeOf<TNewNext>;
2283
- zodClientSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
2284
- zodValidationSchema: TValidationNext;
2285
- };
2286
- transform: (transforms: {
2287
- toClient: (dbValue: number) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>;
2288
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>) => number;
2289
- }) => {
2290
- config: {
2291
- sql: {
2292
- type: "int";
2293
- pk: true;
2294
- };
2295
- zodSqlSchema: import("zod").ZodNumber;
2296
- zodNewSchema: TNewNext;
2297
- initialValue: import("zod").TypeOf<TNewNext>;
2298
- zodClientSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
2299
- zodValidationSchema: TValidationNext;
2300
- } & {
2301
- transforms: {
2302
- toClient: (dbValue: number) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>;
2303
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>) => number;
2304
- };
2305
- };
2306
- };
2307
- };
2308
- client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
2309
- sql: import("zod").ZodNumber;
2310
- initialState: TNewNext;
2311
- }) => TClientNext)) => {
2312
- config: {
2313
- sql: {
2314
- type: "int";
2315
- pk: true;
2316
- };
2317
- zodSqlSchema: import("zod").ZodNumber;
2318
- zodNewSchema: TNewNext;
2319
- initialValue: import("zod").TypeOf<TNewNext>;
2320
- zodClientSchema: TClientNext;
2321
- zodValidationSchema: TClientNext;
2322
- };
2323
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
2324
- sql: import("zod").ZodNumber;
2325
- initialState: TNewNext;
2326
- client: TClientNext;
2327
- }) => TValidationNext)) => {
2328
- config: {
2329
- sql: {
2330
- type: "int";
2331
- pk: true;
2332
- };
2333
- zodSqlSchema: import("zod").ZodNumber;
2334
- zodNewSchema: TNewNext;
2335
- initialValue: import("zod").TypeOf<TNewNext>;
2336
- zodClientSchema: TClientNext;
2337
- zodValidationSchema: TValidationNext;
2338
- };
2339
- transform: (transforms: {
2340
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
2341
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
2342
- }) => {
2343
- config: {
2344
- sql: {
2345
- type: "int";
2346
- pk: true;
2347
- };
2348
- zodSqlSchema: import("zod").ZodNumber;
2349
- zodNewSchema: TNewNext;
2350
- initialValue: import("zod").TypeOf<TNewNext>;
2351
- zodClientSchema: TClientNext;
2352
- zodValidationSchema: TValidationNext;
2353
- } & {
2354
- transforms: {
2355
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
2356
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
2357
- };
2358
- };
2359
- };
2360
- };
2361
- transform: (transforms: {
2362
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
2363
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
2364
- }) => {
2365
- config: {
2366
- sql: {
2367
- type: "int";
2368
- pk: true;
2369
- };
2370
- zodSqlSchema: import("zod").ZodNumber;
2371
- zodNewSchema: TNewNext;
2372
- initialValue: import("zod").TypeOf<TNewNext>;
2373
- zodClientSchema: TClientNext;
2374
- zodValidationSchema: TClientNext;
2375
- } & {
2376
- transforms: {
2377
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
2378
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
2379
- };
2380
- };
2381
- };
2382
- };
2383
- transform: (transforms: {
2384
- toClient: (dbValue: number) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>;
2385
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>) => number;
2386
- }) => {
2387
- config: {
2388
- sql: {
2389
- type: "int";
2390
- pk: true;
2391
- };
2392
- zodSqlSchema: import("zod").ZodNumber;
2393
- zodNewSchema: TNewNext;
2394
- initialValue: import("zod").TypeOf<TNewNext>;
2395
- zodClientSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
2396
- zodValidationSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
2397
- } & {
2398
- transforms: {
2399
- toClient: (dbValue: number) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>;
2400
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>) => number;
2401
- };
2402
- };
2403
- };
2404
- };
2405
- };
2406
- };
2407
- };
2408
- fluffynessScale: {
2409
- config: {
2410
- sql: {
2411
- type: "text";
2412
- };
2413
- zodSqlSchema: import("zod").ZodString;
2414
- zodNewSchema: import("zod").ZodString;
2415
- initialValue: string;
2416
- zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
2417
- zodValidationSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
2418
- } & {
2419
- transforms: {
2420
- toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
2421
- toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
2422
- };
2423
- };
2424
- };
2425
- favourite: {
2426
- config: {
2427
- sql: {
2428
- type: "int";
2429
- };
2430
- zodSqlSchema: import("zod").ZodNumber;
2431
- zodNewSchema: import("zod").ZodNumber;
2432
- initialValue: number;
2433
- zodClientSchema: import("zod").ZodBoolean;
2434
- zodValidationSchema: import("zod").ZodBoolean;
2435
- } & {
2436
- transforms: {
2437
- toClient: (dbValue: number) => boolean;
2438
- toDb: (clientValue: boolean) => number;
2439
- };
2440
- };
2441
- };
2442
- };
2443
- defaultCount: number | undefined;
2444
- };
2445
- };
2446
- pet: {
2447
- _tableName: string;
2448
- id: {
2449
- config: {
2450
- sql: {
2451
- type: "int";
2452
- pk: true;
2453
- };
2454
- zodSqlSchema: import("zod").ZodNumber;
2455
- zodNewSchema: import("zod").ZodNumber;
2456
- initialValue: string;
2457
- zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
2458
- zodValidationSchema: import("zod").ZodString;
2459
- } & {
2460
- transforms: {
2461
- toClient: (dbValue: number) => number;
2462
- toDb: (clientValue: number) => number;
2463
- };
2464
- };
2465
- };
2466
- name: {
2467
- config: {
2468
- sql: {
2469
- type: "varchar";
2470
- length: number;
2471
- };
2472
- zodSqlSchema: import("zod").ZodString;
2473
- zodNewSchema: import("zod").ZodString;
2474
- initialValue: string;
2475
- zodClientSchema: import("zod").ZodString;
2476
- zodValidationSchema: import("zod").ZodString;
2477
- };
2478
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
2479
- sql: import("zod").ZodString;
2480
- initialState: import("zod").ZodString;
2481
- client: import("zod").ZodString;
2482
- }) => TValidationNext)) => {
2483
- config: {
2484
- sql: {
2485
- type: "varchar";
2486
- length: number;
2487
- };
2488
- zodSqlSchema: import("zod").ZodString;
2489
- zodNewSchema: import("zod").ZodString;
2490
- initialValue: string;
2491
- zodClientSchema: import("zod").ZodString;
2492
- zodValidationSchema: TValidationNext;
2493
- };
2494
- transform: (transforms: {
2495
- toClient: (dbValue: string) => string;
2496
- toDb: (clientValue: string) => string;
2497
- }) => {
2498
- config: {
2499
- sql: {
2500
- type: "varchar";
2501
- length: number;
2502
- };
2503
- zodSqlSchema: import("zod").ZodString;
2504
- zodNewSchema: import("zod").ZodString;
2505
- initialValue: string;
2506
- zodClientSchema: import("zod").ZodString;
2507
- zodValidationSchema: TValidationNext;
2508
- } & {
2509
- transforms: {
2510
- toClient: (dbValue: string) => string;
2511
- toDb: (clientValue: string) => string;
2512
- };
2513
- };
2514
- };
2515
- };
2516
- client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
2517
- sql: import("zod").ZodString;
2518
- initialState: import("zod").ZodString;
2519
- }) => TClientNext)) => {
2520
- config: {
2521
- sql: {
2522
- type: "varchar";
2523
- length: number;
2524
- };
2525
- zodSqlSchema: import("zod").ZodString;
2526
- zodNewSchema: import("zod").ZodString;
2527
- initialValue: string;
2528
- zodClientSchema: TClientNext;
2529
- zodValidationSchema: TClientNext;
2530
- };
2531
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
2532
- sql: import("zod").ZodString;
2533
- initialState: import("zod").ZodString;
2534
- client: TClientNext;
2535
- }) => TValidationNext)) => {
2536
- config: {
2537
- sql: {
2538
- type: "varchar";
2539
- length: number;
2540
- };
2541
- zodSqlSchema: import("zod").ZodString;
2542
- zodNewSchema: import("zod").ZodString;
2543
- initialValue: string;
2544
- zodClientSchema: TClientNext;
2545
- zodValidationSchema: TValidationNext;
2546
- };
2547
- transform: (transforms: {
2548
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
2549
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
2550
- }) => {
2551
- config: {
2552
- sql: {
2553
- type: "varchar";
2554
- length: number;
2555
- };
2556
- zodSqlSchema: import("zod").ZodString;
2557
- zodNewSchema: import("zod").ZodString;
2558
- initialValue: string;
2559
- zodClientSchema: TClientNext;
2560
- zodValidationSchema: TValidationNext;
2561
- } & {
2562
- transforms: {
2563
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
2564
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
2565
- };
2566
- };
2567
- };
2568
- };
2569
- transform: (transforms: {
2570
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
2571
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
2572
- }) => {
2573
- config: {
2574
- sql: {
2575
- type: "varchar";
2576
- length: number;
2577
- };
2578
- zodSqlSchema: import("zod").ZodString;
2579
- zodNewSchema: import("zod").ZodString;
2580
- initialValue: string;
2581
- zodClientSchema: TClientNext;
2582
- zodValidationSchema: TClientNext;
2583
- } & {
2584
- transforms: {
2585
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
2586
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
2587
- };
2588
- };
2589
- };
2590
- };
2591
- transform: (transforms: {
2592
- toClient: (dbValue: string) => string;
2593
- toDb: (clientValue: string) => string;
2594
- }) => {
2595
- config: {
2596
- sql: {
2597
- type: "varchar";
2598
- length: number;
2599
- };
2600
- zodSqlSchema: import("zod").ZodString;
2601
- zodNewSchema: import("zod").ZodString;
2602
- initialValue: string;
2603
- zodClientSchema: import("zod").ZodString;
2604
- zodValidationSchema: import("zod").ZodString;
2605
- } & {
2606
- transforms: {
2607
- toClient: (dbValue: string) => string;
2608
- toDb: (clientValue: string) => string;
2609
- };
2610
- };
2611
- };
2612
- initialState: {
2613
- <TDefaultNext>(defaultValue: () => TDefaultNext): {
2614
- config: {
2615
- sql: {
2616
- type: "varchar";
2617
- length: number;
2618
- };
2619
- zodSqlSchema: import("zod").ZodString;
2620
- zodNewSchema: import("zod").ZodString;
2621
- initialValue: TDefaultNext;
2622
- zodClientSchema: import("zod").ZodString;
2623
- zodValidationSchema: import("zod").ZodString;
2624
- };
2625
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
2626
- sql: import("zod").ZodString;
2627
- initialState: import("zod").ZodString;
2628
- client: import("zod").ZodString;
2629
- }) => TValidationNext)) => {
2630
- config: {
2631
- sql: {
2632
- type: "varchar";
2633
- length: number;
2634
- };
2635
- zodSqlSchema: import("zod").ZodString;
2636
- zodNewSchema: import("zod").ZodString;
2637
- initialValue: TDefaultNext;
2638
- zodClientSchema: import("zod").ZodString;
2639
- zodValidationSchema: TValidationNext;
2640
- };
2641
- transform: (transforms: {
2642
- toClient: (dbValue: string) => string;
2643
- toDb: (clientValue: string) => string;
2644
- }) => {
2645
- config: {
2646
- sql: {
2647
- type: "varchar";
2648
- length: number;
2649
- };
2650
- zodSqlSchema: import("zod").ZodString;
2651
- zodNewSchema: import("zod").ZodString;
2652
- initialValue: TDefaultNext;
2653
- zodClientSchema: import("zod").ZodString;
2654
- zodValidationSchema: TValidationNext;
2655
- } & {
2656
- transforms: {
2657
- toClient: (dbValue: string) => string;
2658
- toDb: (clientValue: string) => string;
2659
- };
2660
- };
2661
- };
2662
- };
2663
- client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
2664
- sql: import("zod").ZodString;
2665
- initialState: import("zod").ZodString;
2666
- }) => TClientNext)) => {
2667
- config: {
2668
- sql: {
2669
- type: "varchar";
2670
- length: number;
2671
- };
2672
- zodSqlSchema: import("zod").ZodString;
2673
- zodNewSchema: import("zod").ZodString;
2674
- initialValue: TDefaultNext;
2675
- zodClientSchema: TClientNext;
2676
- zodValidationSchema: TClientNext;
2677
- };
2678
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
2679
- sql: import("zod").ZodString;
2680
- initialState: import("zod").ZodString;
2681
- client: TClientNext;
2682
- }) => TValidationNext)) => {
2683
- config: {
2684
- sql: {
2685
- type: "varchar";
2686
- length: number;
2687
- };
2688
- zodSqlSchema: import("zod").ZodString;
2689
- zodNewSchema: import("zod").ZodString;
2690
- initialValue: TDefaultNext;
2691
- zodClientSchema: TClientNext;
2692
- zodValidationSchema: TValidationNext;
2693
- };
2694
- transform: (transforms: {
2695
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
2696
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
2697
- }) => {
2698
- config: {
2699
- sql: {
2700
- type: "varchar";
2701
- length: number;
2702
- };
2703
- zodSqlSchema: import("zod").ZodString;
2704
- zodNewSchema: import("zod").ZodString;
2705
- initialValue: TDefaultNext;
2706
- zodClientSchema: TClientNext;
2707
- zodValidationSchema: TValidationNext;
2708
- } & {
2709
- transforms: {
2710
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
2711
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
2712
- };
2713
- };
2714
- };
2715
- };
2716
- transform: (transforms: {
2717
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
2718
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
2719
- }) => {
2720
- config: {
2721
- sql: {
2722
- type: "varchar";
2723
- length: number;
2724
- };
2725
- zodSqlSchema: import("zod").ZodString;
2726
- zodNewSchema: import("zod").ZodString;
2727
- initialValue: TDefaultNext;
2728
- zodClientSchema: TClientNext;
2729
- zodValidationSchema: TClientNext;
2730
- } & {
2731
- transforms: {
2732
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
2733
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
2734
- };
2735
- };
2736
- };
2737
- };
2738
- transform: (transforms: {
2739
- toClient: (dbValue: string) => string;
2740
- toDb: (clientValue: string) => string;
2741
- }) => {
2742
- config: {
2743
- sql: {
2744
- type: "varchar";
2745
- length: number;
2746
- };
2747
- zodSqlSchema: import("zod").ZodString;
2748
- zodNewSchema: import("zod").ZodString;
2749
- initialValue: TDefaultNext;
2750
- zodClientSchema: import("zod").ZodString;
2751
- zodValidationSchema: import("zod").ZodString;
2752
- } & {
2753
- transforms: {
2754
- toClient: (dbValue: string) => string;
2755
- toDb: (clientValue: string) => string;
2756
- };
2757
- };
2758
- };
2759
- };
2760
- <TNewNext extends import("zod").ZodTypeAny, TDefaultNext>(schema: TNewNext | ((tools: {
2761
- sql: import("zod").ZodString;
2762
- }) => TNewNext), defaultValue: () => TDefaultNext): {
2763
- config: {
2764
- sql: {
2765
- type: "varchar";
2766
- length: number;
2767
- };
2768
- zodSqlSchema: import("zod").ZodString;
2769
- zodNewSchema: TNewNext;
2770
- initialValue: import("zod").TypeOf<TNewNext>;
2771
- zodClientSchema: import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>;
2772
- zodValidationSchema: import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>;
2773
- };
2774
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
2775
- sql: import("zod").ZodString;
2776
- initialState: TNewNext;
2777
- client: import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>;
2778
- }) => TValidationNext)) => {
2779
- config: {
2780
- sql: {
2781
- type: "varchar";
2782
- length: number;
2783
- };
2784
- zodSqlSchema: import("zod").ZodString;
2785
- zodNewSchema: TNewNext;
2786
- initialValue: import("zod").TypeOf<TNewNext>;
2787
- zodClientSchema: import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>;
2788
- zodValidationSchema: TValidationNext;
2789
- };
2790
- transform: (transforms: {
2791
- toClient: (dbValue: string) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>;
2792
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>) => string;
2793
- }) => {
2794
- config: {
2795
- sql: {
2796
- type: "varchar";
2797
- length: number;
2798
- };
2799
- zodSqlSchema: import("zod").ZodString;
2800
- zodNewSchema: TNewNext;
2801
- initialValue: import("zod").TypeOf<TNewNext>;
2802
- zodClientSchema: import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>;
2803
- zodValidationSchema: TValidationNext;
2804
- } & {
2805
- transforms: {
2806
- toClient: (dbValue: string) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>;
2807
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>) => string;
2808
- };
2809
- };
2810
- };
2811
- };
2812
- client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
2813
- sql: import("zod").ZodString;
2814
- initialState: TNewNext;
2815
- }) => TClientNext)) => {
2816
- config: {
2817
- sql: {
2818
- type: "varchar";
2819
- length: number;
2820
- };
2821
- zodSqlSchema: import("zod").ZodString;
2822
- zodNewSchema: TNewNext;
2823
- initialValue: import("zod").TypeOf<TNewNext>;
2824
- zodClientSchema: TClientNext;
2825
- zodValidationSchema: TClientNext;
287
+ pk: true;
288
+ }, import("zod").ZodNumber, import("zod").ZodNumber, number, import("zod").ZodNumber, import("zod").ZodNumber>;
2826
289
  };
2827
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
2828
- sql: import("zod").ZodString;
2829
- initialState: TNewNext;
2830
- client: TClientNext;
2831
- }) => TValidationNext)) => {
290
+ fluffynessScale: {
2832
291
  config: {
2833
292
  sql: {
2834
- type: "varchar";
2835
- length: number;
293
+ type: "text";
2836
294
  };
2837
295
  zodSqlSchema: import("zod").ZodString;
2838
- zodNewSchema: TNewNext;
2839
- initialValue: import("zod").TypeOf<TNewNext>;
2840
- zodClientSchema: TClientNext;
2841
- zodValidationSchema: TValidationNext;
2842
- };
2843
- transform: (transforms: {
2844
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
2845
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
2846
- }) => {
2847
- config: {
2848
- sql: {
2849
- type: "varchar";
2850
- length: number;
2851
- };
2852
- zodSqlSchema: import("zod").ZodString;
2853
- zodNewSchema: TNewNext;
2854
- initialValue: import("zod").TypeOf<TNewNext>;
2855
- zodClientSchema: TClientNext;
2856
- zodValidationSchema: TValidationNext;
2857
- } & {
2858
- transforms: {
2859
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
2860
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
2861
- };
296
+ zodNewSchema: import("zod").ZodString;
297
+ initialValue: string;
298
+ zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
299
+ zodValidationSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
300
+ } & {
301
+ transforms: {
302
+ toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
303
+ toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
2862
304
  };
2863
305
  };
2864
306
  };
2865
- transform: (transforms: {
2866
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
2867
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
2868
- }) => {
307
+ favourite: {
2869
308
  config: {
2870
309
  sql: {
2871
- type: "varchar";
2872
- length: number;
310
+ type: "int";
2873
311
  };
2874
- zodSqlSchema: import("zod").ZodString;
2875
- zodNewSchema: TNewNext;
2876
- initialValue: import("zod").TypeOf<TNewNext>;
2877
- zodClientSchema: TClientNext;
2878
- zodValidationSchema: TClientNext;
312
+ zodSqlSchema: import("zod").ZodNumber;
313
+ zodNewSchema: import("zod").ZodNumber;
314
+ initialValue: number;
315
+ zodClientSchema: import("zod").ZodBoolean;
316
+ zodValidationSchema: import("zod").ZodBoolean;
2879
317
  } & {
2880
318
  transforms: {
2881
- toClient: (dbValue: string) => import("zod").TypeOf<TClientNext>;
2882
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => string;
319
+ toClient: (dbValue: number) => boolean;
320
+ toDb: (clientValue: boolean) => number;
2883
321
  };
2884
322
  };
2885
323
  };
2886
324
  };
2887
- transform: (transforms: {
2888
- toClient: (dbValue: string) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>;
2889
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>) => string;
2890
- }) => {
2891
- config: {
2892
- sql: {
2893
- type: "varchar";
2894
- length: number;
2895
- };
2896
- zodSqlSchema: import("zod").ZodString;
2897
- zodNewSchema: TNewNext;
2898
- initialValue: import("zod").TypeOf<TNewNext>;
2899
- zodClientSchema: import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>;
2900
- zodValidationSchema: import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>;
2901
- } & {
2902
- transforms: {
2903
- toClient: (dbValue: string) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>;
2904
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends string ? TNewNext : import("zod").ZodUnion<[import("zod").ZodString, TNewNext]>>) => string;
2905
- };
2906
- };
2907
- };
2908
- };
2909
- };
2910
- };
2911
- userId: {
2912
- type: "reference";
2913
- to: () => {
2914
- config: {
2915
- sql: {
2916
- type: "int";
2917
- pk: true;
2918
- };
2919
- zodSqlSchema: import("zod").ZodNumber;
2920
- zodNewSchema: import("zod").ZodNumber;
2921
- initialValue: number;
2922
- zodClientSchema: import("zod").ZodNumber;
2923
- zodValidationSchema: import("zod").ZodNumber;
2924
- };
2925
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
2926
- sql: import("zod").ZodNumber;
2927
- initialState: import("zod").ZodNumber;
2928
- client: import("zod").ZodNumber;
2929
- }) => TValidationNext)) => {
2930
- config: {
2931
- sql: {
2932
- type: "int";
2933
- pk: true;
2934
- };
2935
- zodSqlSchema: import("zod").ZodNumber;
2936
- zodNewSchema: import("zod").ZodNumber;
2937
- initialValue: number;
2938
- zodClientSchema: import("zod").ZodNumber;
2939
- zodValidationSchema: TValidationNext;
2940
- };
2941
- transform: (transforms: {
2942
- toClient: (dbValue: number) => number;
2943
- toDb: (clientValue: number) => number;
2944
- }) => {
2945
- config: {
2946
- sql: {
2947
- type: "int";
2948
- pk: true;
2949
- };
2950
- zodSqlSchema: import("zod").ZodNumber;
2951
- zodNewSchema: import("zod").ZodNumber;
2952
- initialValue: number;
2953
- zodClientSchema: import("zod").ZodNumber;
2954
- zodValidationSchema: TValidationNext;
2955
- } & {
2956
- transforms: {
2957
- toClient: (dbValue: number) => number;
2958
- toDb: (clientValue: number) => number;
2959
- };
2960
- };
2961
- };
2962
- };
2963
- client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
2964
- sql: import("zod").ZodNumber;
2965
- initialState: import("zod").ZodNumber;
2966
- }) => TClientNext)) => {
2967
- config: {
2968
- sql: {
2969
- type: "int";
2970
- pk: true;
2971
- };
2972
- zodSqlSchema: import("zod").ZodNumber;
2973
- zodNewSchema: import("zod").ZodNumber;
2974
- initialValue: number;
2975
- zodClientSchema: TClientNext;
2976
- zodValidationSchema: TClientNext;
2977
- };
2978
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
2979
- sql: import("zod").ZodNumber;
2980
- initialState: import("zod").ZodNumber;
2981
- client: TClientNext;
2982
- }) => TValidationNext)) => {
2983
- config: {
2984
- sql: {
2985
- type: "int";
2986
- pk: true;
2987
- };
2988
- zodSqlSchema: import("zod").ZodNumber;
2989
- zodNewSchema: import("zod").ZodNumber;
2990
- initialValue: number;
2991
- zodClientSchema: TClientNext;
2992
- zodValidationSchema: TValidationNext;
2993
- };
2994
- transform: (transforms: {
2995
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
2996
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
2997
- }) => {
325
+ defaultCount?: number;
326
+ } & {
327
+ type: "belongsTo";
328
+ }) | ({
329
+ fromKey: string;
330
+ toKey: () => any;
331
+ schema: () => {
332
+ _tableName: string;
333
+ id: {
2998
334
  config: {
2999
335
  sql: {
3000
336
  type: "int";
@@ -3002,93 +338,83 @@ declare const schemas: {
3002
338
  };
3003
339
  zodSqlSchema: import("zod").ZodNumber;
3004
340
  zodNewSchema: import("zod").ZodNumber;
3005
- initialValue: number;
3006
- zodClientSchema: TClientNext;
3007
- zodValidationSchema: TValidationNext;
341
+ initialValue: string;
342
+ zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
343
+ zodValidationSchema: import("zod").ZodString;
3008
344
  } & {
3009
345
  transforms: {
3010
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
3011
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
346
+ toClient: (dbValue: number) => number;
347
+ toDb: (clientValue: number) => number;
3012
348
  };
3013
349
  };
3014
350
  };
3015
- };
3016
- transform: (transforms: {
3017
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
3018
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
3019
- }) => {
3020
- config: {
3021
- sql: {
351
+ name: import("..").Builder<"sql", {
352
+ type: "varchar";
353
+ length: number;
354
+ }, import("zod").ZodString, import("zod").ZodString, string, import("zod").ZodString, import("zod").ZodString>;
355
+ userId: {
356
+ type: "reference";
357
+ to: () => import("..").Builder<"sql", {
3022
358
  type: "int";
3023
359
  pk: true;
3024
- };
3025
- zodSqlSchema: import("zod").ZodNumber;
3026
- zodNewSchema: import("zod").ZodNumber;
3027
- initialValue: number;
3028
- zodClientSchema: TClientNext;
3029
- zodValidationSchema: TClientNext;
3030
- } & {
3031
- transforms: {
3032
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
3033
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
3034
- };
3035
- };
3036
- };
3037
- };
3038
- transform: (transforms: {
3039
- toClient: (dbValue: number) => number;
3040
- toDb: (clientValue: number) => number;
3041
- }) => {
3042
- config: {
3043
- sql: {
3044
- type: "int";
3045
- pk: true;
360
+ }, import("zod").ZodNumber, import("zod").ZodNumber, number, import("zod").ZodNumber, import("zod").ZodNumber>;
3046
361
  };
3047
- zodSqlSchema: import("zod").ZodNumber;
3048
- zodNewSchema: import("zod").ZodNumber;
3049
- initialValue: number;
3050
- zodClientSchema: import("zod").ZodNumber;
3051
- zodValidationSchema: import("zod").ZodNumber;
3052
- } & {
3053
- transforms: {
3054
- toClient: (dbValue: number) => number;
3055
- toDb: (clientValue: number) => number;
3056
- };
3057
- };
3058
- };
3059
- initialState: {
3060
- <TDefaultNext>(defaultValue: () => TDefaultNext): {
3061
- config: {
3062
- sql: {
3063
- type: "int";
3064
- pk: true;
362
+ fluffynessScale: {
363
+ config: {
364
+ sql: {
365
+ type: "text";
366
+ };
367
+ zodSqlSchema: import("zod").ZodString;
368
+ zodNewSchema: import("zod").ZodString;
369
+ initialValue: string;
370
+ zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
371
+ zodValidationSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
372
+ } & {
373
+ transforms: {
374
+ toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
375
+ toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
376
+ };
3065
377
  };
3066
- zodSqlSchema: import("zod").ZodNumber;
3067
- zodNewSchema: import("zod").ZodNumber;
3068
- initialValue: TDefaultNext;
3069
- zodClientSchema: import("zod").ZodNumber;
3070
- zodValidationSchema: import("zod").ZodNumber;
3071
378
  };
3072
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
3073
- sql: import("zod").ZodNumber;
3074
- initialState: import("zod").ZodNumber;
3075
- client: import("zod").ZodNumber;
3076
- }) => TValidationNext)) => {
379
+ favourite: {
3077
380
  config: {
3078
381
  sql: {
3079
382
  type: "int";
3080
- pk: true;
3081
383
  };
3082
384
  zodSqlSchema: import("zod").ZodNumber;
3083
385
  zodNewSchema: import("zod").ZodNumber;
3084
- initialValue: TDefaultNext;
3085
- zodClientSchema: import("zod").ZodNumber;
3086
- zodValidationSchema: TValidationNext;
386
+ initialValue: number;
387
+ zodClientSchema: import("zod").ZodBoolean;
388
+ zodValidationSchema: import("zod").ZodBoolean;
389
+ } & {
390
+ transforms: {
391
+ toClient: (dbValue: number) => boolean;
392
+ toDb: (clientValue: boolean) => number;
393
+ };
3087
394
  };
3088
- transform: (transforms: {
3089
- toClient: (dbValue: number) => number;
3090
- toDb: (clientValue: number) => number;
3091
- }) => {
395
+ };
396
+ };
397
+ defaultCount?: number;
398
+ } & {
399
+ type: "manyToMany";
400
+ });
401
+ zodSqlSchema: import("zod").ZodArray<import("zod").ZodAny, "many">;
402
+ zodNewSchema: import("zod").ZodArray<import("zod").ZodAny, "many">;
403
+ initialValue: any[];
404
+ zodClientSchema: import("zod").ZodArray<import("zod").ZodAny, "many">;
405
+ zodValidationSchema: import("zod").ZodArray<import("zod").ZodAny, "many">;
406
+ };
407
+ transform: (transforms: {
408
+ toClient: (dbValue: any[]) => any[];
409
+ toDb: (clientValue: any[]) => any[];
410
+ }) => {
411
+ config: {
412
+ sql: ({
413
+ fromKey: string;
414
+ toKey: () => any;
415
+ schema: () => {
416
+ _tableName: string;
417
+ id: {
3092
418
  config: {
3093
419
  sql: {
3094
420
  type: "int";
@@ -3096,9 +422,9 @@ declare const schemas: {
3096
422
  };
3097
423
  zodSqlSchema: import("zod").ZodNumber;
3098
424
  zodNewSchema: import("zod").ZodNumber;
3099
- initialValue: TDefaultNext;
3100
- zodClientSchema: import("zod").ZodNumber;
3101
- zodValidationSchema: TValidationNext;
425
+ initialValue: string;
426
+ zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
427
+ zodValidationSchema: import("zod").ZodString;
3102
428
  } & {
3103
429
  transforms: {
3104
430
  toClient: (dbValue: number) => number;
@@ -3106,64 +432,61 @@ declare const schemas: {
3106
432
  };
3107
433
  };
3108
434
  };
3109
- };
3110
- client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
3111
- sql: import("zod").ZodNumber;
3112
- initialState: import("zod").ZodNumber;
3113
- }) => TClientNext)) => {
3114
- config: {
3115
- sql: {
435
+ name: import("..").Builder<"sql", {
436
+ type: "varchar";
437
+ length: number;
438
+ }, import("zod").ZodString, import("zod").ZodString, string, import("zod").ZodString, import("zod").ZodString>;
439
+ userId: {
440
+ type: "reference";
441
+ to: () => import("..").Builder<"sql", {
3116
442
  type: "int";
3117
443
  pk: true;
444
+ }, import("zod").ZodNumber, import("zod").ZodNumber, number, import("zod").ZodNumber, import("zod").ZodNumber>;
445
+ };
446
+ fluffynessScale: {
447
+ config: {
448
+ sql: {
449
+ type: "text";
450
+ };
451
+ zodSqlSchema: import("zod").ZodString;
452
+ zodNewSchema: import("zod").ZodString;
453
+ initialValue: string;
454
+ zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
455
+ zodValidationSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
456
+ } & {
457
+ transforms: {
458
+ toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
459
+ toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
460
+ };
3118
461
  };
3119
- zodSqlSchema: import("zod").ZodNumber;
3120
- zodNewSchema: import("zod").ZodNumber;
3121
- initialValue: TDefaultNext;
3122
- zodClientSchema: TClientNext;
3123
- zodValidationSchema: TClientNext;
3124
462
  };
3125
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
3126
- sql: import("zod").ZodNumber;
3127
- initialState: import("zod").ZodNumber;
3128
- client: TClientNext;
3129
- }) => TValidationNext)) => {
463
+ favourite: {
3130
464
  config: {
3131
465
  sql: {
3132
466
  type: "int";
3133
- pk: true;
3134
467
  };
3135
468
  zodSqlSchema: import("zod").ZodNumber;
3136
469
  zodNewSchema: import("zod").ZodNumber;
3137
- initialValue: TDefaultNext;
3138
- zodClientSchema: TClientNext;
3139
- zodValidationSchema: TValidationNext;
3140
- };
3141
- transform: (transforms: {
3142
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
3143
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
3144
- }) => {
3145
- config: {
3146
- sql: {
3147
- type: "int";
3148
- pk: true;
3149
- };
3150
- zodSqlSchema: import("zod").ZodNumber;
3151
- zodNewSchema: import("zod").ZodNumber;
3152
- initialValue: TDefaultNext;
3153
- zodClientSchema: TClientNext;
3154
- zodValidationSchema: TValidationNext;
3155
- } & {
3156
- transforms: {
3157
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
3158
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
3159
- };
470
+ initialValue: number;
471
+ zodClientSchema: import("zod").ZodBoolean;
472
+ zodValidationSchema: import("zod").ZodBoolean;
473
+ } & {
474
+ transforms: {
475
+ toClient: (dbValue: number) => boolean;
476
+ toDb: (clientValue: boolean) => number;
3160
477
  };
3161
478
  };
3162
479
  };
3163
- transform: (transforms: {
3164
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
3165
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
3166
- }) => {
480
+ };
481
+ defaultCount?: number;
482
+ } & {
483
+ type: "hasMany";
484
+ }) | ({
485
+ fromKey: string;
486
+ toKey: () => any;
487
+ schema: () => {
488
+ _tableName: string;
489
+ id: {
3167
490
  config: {
3168
491
  sql: {
3169
492
  type: "int";
@@ -3171,191 +494,255 @@ declare const schemas: {
3171
494
  };
3172
495
  zodSqlSchema: import("zod").ZodNumber;
3173
496
  zodNewSchema: import("zod").ZodNumber;
3174
- initialValue: TDefaultNext;
3175
- zodClientSchema: TClientNext;
3176
- zodValidationSchema: TClientNext;
497
+ initialValue: string;
498
+ zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
499
+ zodValidationSchema: import("zod").ZodString;
3177
500
  } & {
3178
501
  transforms: {
3179
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
3180
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
502
+ toClient: (dbValue: number) => number;
503
+ toDb: (clientValue: number) => number;
3181
504
  };
3182
505
  };
3183
506
  };
3184
- };
3185
- transform: (transforms: {
3186
- toClient: (dbValue: number) => number;
3187
- toDb: (clientValue: number) => number;
3188
- }) => {
3189
- config: {
3190
- sql: {
507
+ name: import("..").Builder<"sql", {
508
+ type: "varchar";
509
+ length: number;
510
+ }, import("zod").ZodString, import("zod").ZodString, string, import("zod").ZodString, import("zod").ZodString>;
511
+ userId: {
512
+ type: "reference";
513
+ to: () => import("..").Builder<"sql", {
3191
514
  type: "int";
3192
515
  pk: true;
3193
- };
3194
- zodSqlSchema: import("zod").ZodNumber;
3195
- zodNewSchema: import("zod").ZodNumber;
3196
- initialValue: TDefaultNext;
3197
- zodClientSchema: import("zod").ZodNumber;
3198
- zodValidationSchema: import("zod").ZodNumber;
3199
- } & {
3200
- transforms: {
3201
- toClient: (dbValue: number) => number;
3202
- toDb: (clientValue: number) => number;
3203
- };
516
+ }, import("zod").ZodNumber, import("zod").ZodNumber, number, import("zod").ZodNumber, import("zod").ZodNumber>;
3204
517
  };
3205
- };
3206
- };
3207
- <TNewNext extends import("zod").ZodTypeAny, TDefaultNext>(schema: TNewNext | ((tools: {
3208
- sql: import("zod").ZodNumber;
3209
- }) => TNewNext), defaultValue: () => TDefaultNext): {
3210
- config: {
3211
- sql: {
3212
- type: "int";
3213
- pk: true;
518
+ fluffynessScale: {
519
+ config: {
520
+ sql: {
521
+ type: "text";
522
+ };
523
+ zodSqlSchema: import("zod").ZodString;
524
+ zodNewSchema: import("zod").ZodString;
525
+ initialValue: string;
526
+ zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
527
+ zodValidationSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
528
+ } & {
529
+ transforms: {
530
+ toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
531
+ toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
532
+ };
533
+ };
3214
534
  };
3215
- zodSqlSchema: import("zod").ZodNumber;
3216
- zodNewSchema: TNewNext;
3217
- initialValue: import("zod").TypeOf<TNewNext>;
3218
- zodClientSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
3219
- zodValidationSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
3220
- };
3221
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
3222
- sql: import("zod").ZodNumber;
3223
- initialState: TNewNext;
3224
- client: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
3225
- }) => TValidationNext)) => {
3226
- config: {
3227
- sql: {
3228
- type: "int";
3229
- pk: true;
535
+ favourite: {
536
+ config: {
537
+ sql: {
538
+ type: "int";
539
+ };
540
+ zodSqlSchema: import("zod").ZodNumber;
541
+ zodNewSchema: import("zod").ZodNumber;
542
+ initialValue: number;
543
+ zodClientSchema: import("zod").ZodBoolean;
544
+ zodValidationSchema: import("zod").ZodBoolean;
545
+ } & {
546
+ transforms: {
547
+ toClient: (dbValue: number) => boolean;
548
+ toDb: (clientValue: boolean) => number;
549
+ };
3230
550
  };
3231
- zodSqlSchema: import("zod").ZodNumber;
3232
- zodNewSchema: TNewNext;
3233
- initialValue: import("zod").TypeOf<TNewNext>;
3234
- zodClientSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
3235
- zodValidationSchema: TValidationNext;
3236
551
  };
3237
- transform: (transforms: {
3238
- toClient: (dbValue: number) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>;
3239
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>) => number;
3240
- }) => {
552
+ };
553
+ defaultCount?: number;
554
+ } & {
555
+ type: "hasOne";
556
+ }) | ({
557
+ fromKey: string;
558
+ toKey: () => any;
559
+ schema: () => {
560
+ _tableName: string;
561
+ id: {
3241
562
  config: {
3242
563
  sql: {
3243
564
  type: "int";
3244
565
  pk: true;
3245
566
  };
3246
567
  zodSqlSchema: import("zod").ZodNumber;
3247
- zodNewSchema: TNewNext;
3248
- initialValue: import("zod").TypeOf<TNewNext>;
3249
- zodClientSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
3250
- zodValidationSchema: TValidationNext;
568
+ zodNewSchema: import("zod").ZodNumber;
569
+ initialValue: string;
570
+ zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
571
+ zodValidationSchema: import("zod").ZodString;
3251
572
  } & {
3252
573
  transforms: {
3253
- toClient: (dbValue: number) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>;
3254
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>) => number;
574
+ toClient: (dbValue: number) => number;
575
+ toDb: (clientValue: number) => number;
3255
576
  };
3256
577
  };
3257
578
  };
3258
- };
3259
- client: <TClientNext extends import("zod").ZodTypeAny>(schema: TClientNext | ((tools: {
3260
- sql: import("zod").ZodNumber;
3261
- initialState: TNewNext;
3262
- }) => TClientNext)) => {
3263
- config: {
3264
- sql: {
579
+ name: import("..").Builder<"sql", {
580
+ type: "varchar";
581
+ length: number;
582
+ }, import("zod").ZodString, import("zod").ZodString, string, import("zod").ZodString, import("zod").ZodString>;
583
+ userId: {
584
+ type: "reference";
585
+ to: () => import("..").Builder<"sql", {
3265
586
  type: "int";
3266
587
  pk: true;
588
+ }, import("zod").ZodNumber, import("zod").ZodNumber, number, import("zod").ZodNumber, import("zod").ZodNumber>;
589
+ };
590
+ fluffynessScale: {
591
+ config: {
592
+ sql: {
593
+ type: "text";
594
+ };
595
+ zodSqlSchema: import("zod").ZodString;
596
+ zodNewSchema: import("zod").ZodString;
597
+ initialValue: string;
598
+ zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
599
+ zodValidationSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
600
+ } & {
601
+ transforms: {
602
+ toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
603
+ toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
604
+ };
3267
605
  };
3268
- zodSqlSchema: import("zod").ZodNumber;
3269
- zodNewSchema: TNewNext;
3270
- initialValue: import("zod").TypeOf<TNewNext>;
3271
- zodClientSchema: TClientNext;
3272
- zodValidationSchema: TClientNext;
3273
606
  };
3274
- validation: <TValidationNext extends import("zod").ZodTypeAny>(schema: TValidationNext | ((tools: {
3275
- sql: import("zod").ZodNumber;
3276
- initialState: TNewNext;
3277
- client: TClientNext;
3278
- }) => TValidationNext)) => {
607
+ favourite: {
3279
608
  config: {
3280
609
  sql: {
3281
610
  type: "int";
3282
- pk: true;
3283
611
  };
3284
612
  zodSqlSchema: import("zod").ZodNumber;
3285
- zodNewSchema: TNewNext;
3286
- initialValue: import("zod").TypeOf<TNewNext>;
3287
- zodClientSchema: TClientNext;
3288
- zodValidationSchema: TValidationNext;
3289
- };
3290
- transform: (transforms: {
3291
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
3292
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
3293
- }) => {
3294
- config: {
3295
- sql: {
3296
- type: "int";
3297
- pk: true;
3298
- };
3299
- zodSqlSchema: import("zod").ZodNumber;
3300
- zodNewSchema: TNewNext;
3301
- initialValue: import("zod").TypeOf<TNewNext>;
3302
- zodClientSchema: TClientNext;
3303
- zodValidationSchema: TValidationNext;
3304
- } & {
3305
- transforms: {
3306
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
3307
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
3308
- };
613
+ zodNewSchema: import("zod").ZodNumber;
614
+ initialValue: number;
615
+ zodClientSchema: import("zod").ZodBoolean;
616
+ zodValidationSchema: import("zod").ZodBoolean;
617
+ } & {
618
+ transforms: {
619
+ toClient: (dbValue: number) => boolean;
620
+ toDb: (clientValue: boolean) => number;
3309
621
  };
3310
622
  };
3311
623
  };
3312
- transform: (transforms: {
3313
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
3314
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
3315
- }) => {
624
+ };
625
+ defaultCount?: number;
626
+ } & {
627
+ type: "belongsTo";
628
+ }) | ({
629
+ fromKey: string;
630
+ toKey: () => any;
631
+ schema: () => {
632
+ _tableName: string;
633
+ id: {
3316
634
  config: {
3317
635
  sql: {
3318
636
  type: "int";
3319
637
  pk: true;
3320
638
  };
3321
639
  zodSqlSchema: import("zod").ZodNumber;
3322
- zodNewSchema: TNewNext;
3323
- initialValue: import("zod").TypeOf<TNewNext>;
3324
- zodClientSchema: TClientNext;
3325
- zodValidationSchema: TClientNext;
640
+ zodNewSchema: import("zod").ZodNumber;
641
+ initialValue: string;
642
+ zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
643
+ zodValidationSchema: import("zod").ZodString;
3326
644
  } & {
3327
645
  transforms: {
3328
- toClient: (dbValue: number) => import("zod").TypeOf<TClientNext>;
3329
- toDb: (clientValue: import("zod").TypeOf<TClientNext>) => number;
646
+ toClient: (dbValue: number) => number;
647
+ toDb: (clientValue: number) => number;
3330
648
  };
3331
649
  };
3332
650
  };
3333
- };
3334
- transform: (transforms: {
3335
- toClient: (dbValue: number) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>;
3336
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>) => number;
3337
- }) => {
3338
- config: {
3339
- sql: {
651
+ name: import("..").Builder<"sql", {
652
+ type: "varchar";
653
+ length: number;
654
+ }, import("zod").ZodString, import("zod").ZodString, string, import("zod").ZodString, import("zod").ZodString>;
655
+ userId: {
656
+ type: "reference";
657
+ to: () => import("..").Builder<"sql", {
3340
658
  type: "int";
3341
659
  pk: true;
660
+ }, import("zod").ZodNumber, import("zod").ZodNumber, number, import("zod").ZodNumber, import("zod").ZodNumber>;
661
+ };
662
+ fluffynessScale: {
663
+ config: {
664
+ sql: {
665
+ type: "text";
666
+ };
667
+ zodSqlSchema: import("zod").ZodString;
668
+ zodNewSchema: import("zod").ZodString;
669
+ initialValue: string;
670
+ zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
671
+ zodValidationSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
672
+ } & {
673
+ transforms: {
674
+ toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
675
+ toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
676
+ };
3342
677
  };
3343
- zodSqlSchema: import("zod").ZodNumber;
3344
- zodNewSchema: TNewNext;
3345
- initialValue: import("zod").TypeOf<TNewNext>;
3346
- zodClientSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
3347
- zodValidationSchema: import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>;
3348
- } & {
3349
- transforms: {
3350
- toClient: (dbValue: number) => import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>;
3351
- toDb: (clientValue: import("zod").TypeOf<import("zod").TypeOf<TNewNext> extends number ? TNewNext : import("zod").ZodUnion<[import("zod").ZodNumber, TNewNext]>>) => number;
678
+ };
679
+ favourite: {
680
+ config: {
681
+ sql: {
682
+ type: "int";
683
+ };
684
+ zodSqlSchema: import("zod").ZodNumber;
685
+ zodNewSchema: import("zod").ZodNumber;
686
+ initialValue: number;
687
+ zodClientSchema: import("zod").ZodBoolean;
688
+ zodValidationSchema: import("zod").ZodBoolean;
689
+ } & {
690
+ transforms: {
691
+ toClient: (dbValue: number) => boolean;
692
+ toDb: (clientValue: boolean) => number;
693
+ };
3352
694
  };
3353
695
  };
3354
696
  };
697
+ defaultCount?: number;
698
+ } & {
699
+ type: "manyToMany";
700
+ });
701
+ zodSqlSchema: import("zod").ZodArray<import("zod").ZodAny, "many">;
702
+ zodNewSchema: import("zod").ZodArray<import("zod").ZodAny, "many">;
703
+ initialValue: any[];
704
+ zodClientSchema: import("zod").ZodArray<import("zod").ZodAny, "many">;
705
+ zodValidationSchema: import("zod").ZodArray<import("zod").ZodAny, "many">;
706
+ } & {
707
+ transforms: {
708
+ toClient: (dbValue: any[]) => any[];
709
+ toDb: (clientValue: any[]) => any[];
3355
710
  };
3356
711
  };
3357
712
  };
3358
713
  };
714
+ };
715
+ pet: {
716
+ _tableName: string;
717
+ id: {
718
+ config: {
719
+ sql: {
720
+ type: "int";
721
+ pk: true;
722
+ };
723
+ zodSqlSchema: import("zod").ZodNumber;
724
+ zodNewSchema: import("zod").ZodNumber;
725
+ initialValue: string;
726
+ zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
727
+ zodValidationSchema: import("zod").ZodString;
728
+ } & {
729
+ transforms: {
730
+ toClient: (dbValue: number) => number;
731
+ toDb: (clientValue: number) => number;
732
+ };
733
+ };
734
+ };
735
+ name: import("..").Builder<"sql", {
736
+ type: "varchar";
737
+ length: number;
738
+ }, import("zod").ZodString, import("zod").ZodString, string, import("zod").ZodString, import("zod").ZodString>;
739
+ userId: {
740
+ type: "reference";
741
+ to: () => import("..").Builder<"sql", {
742
+ type: "int";
743
+ pk: true;
744
+ }, import("zod").ZodNumber, import("zod").ZodNumber, number, import("zod").ZodNumber, import("zod").ZodNumber>;
745
+ };
3359
746
  fluffynessScale: {
3360
747
  config: {
3361
748
  sql: {