cogsbox-shape 0.5.64 → 0.5.66

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/dist/schema.d.ts +67 -65
  2. package/dist/schema.js +227 -159
  3. package/package.json +7 -3
  4. package/dist/example/schema.d.ts +0 -1036
  5. package/dist/example/schema.js +0 -6
  6. package/dist/example/user.d.ts +0 -1034
  7. package/dist/example/user.js +0 -77
package/dist/example/schema.d.ts DELETED
@@ -1,1036 +0,0 @@
1
- declare const schemas: {
2
- user: {
3
- _tableName: string;
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>;
8
- firstname: {
9
- config: {
10
- sql: {
11
- type: "varchar";
12
- length: number;
13
- };
14
- zodSqlSchema: import("zod").ZodString;
15
- zodNewSchema: import("zod").ZodString;
16
- initialValue: string;
17
- zodClientSchema: import("zod").ZodString;
18
- zodValidationSchema: import("zod").ZodString;
19
- };
20
- transform: (transforms: {
21
- toClient: (dbValue: string) => string;
22
- toDb: (clientValue: string) => string;
23
- }) => {
24
- config: {
25
- sql: {
26
- type: "varchar";
27
- length: number;
28
- };
29
- zodSqlSchema: import("zod").ZodString;
30
- zodNewSchema: import("zod").ZodString;
31
- initialValue: string;
32
- zodClientSchema: import("zod").ZodString;
33
- zodValidationSchema: import("zod").ZodString;
34
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
35
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
36
- } & {
37
- transforms: {
38
- toClient: (dbValue: string) => string;
39
- toDb: (clientValue: string) => string;
40
- };
41
- };
42
- };
43
- };
44
- surname: {
45
- config: {
46
- sql: {
47
- type: "varchar";
48
- length: number;
49
- };
50
- zodSqlSchema: import("zod").ZodString;
51
- zodNewSchema: import("zod").ZodString;
52
- initialValue: string;
53
- zodClientSchema: import("zod").ZodString;
54
- zodValidationSchema: import("zod").ZodString;
55
- };
56
- transform: (transforms: {
57
- toClient: (dbValue: string) => string;
58
- toDb: (clientValue: string) => string;
59
- }) => {
60
- config: {
61
- sql: {
62
- type: "varchar";
63
- length: number;
64
- };
65
- zodSqlSchema: import("zod").ZodString;
66
- zodNewSchema: import("zod").ZodString;
67
- initialValue: string;
68
- zodClientSchema: import("zod").ZodString;
69
- zodValidationSchema: import("zod").ZodString;
70
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
71
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
72
- } & {
73
- transforms: {
74
- toClient: (dbValue: string) => string;
75
- toDb: (clientValue: string) => string;
76
- };
77
- };
78
- };
79
- };
80
- email: {
81
- config: {
82
- sql: {
83
- type: "varchar";
84
- length: number;
85
- };
86
- zodSqlSchema: import("zod").ZodString;
87
- zodNewSchema: import("zod").ZodString;
88
- initialValue: string;
89
- zodClientSchema: import("zod").ZodString;
90
- zodValidationSchema: import("zod").ZodString;
91
- };
92
- transform: (transforms: {
93
- toClient: (dbValue: string) => string;
94
- toDb: (clientValue: string) => string;
95
- }) => {
96
- config: {
97
- sql: {
98
- type: "varchar";
99
- length: number;
100
- };
101
- zodSqlSchema: import("zod").ZodString;
102
- zodNewSchema: import("zod").ZodString;
103
- initialValue: string;
104
- zodClientSchema: import("zod").ZodString;
105
- zodValidationSchema: import("zod").ZodString;
106
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
107
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
108
- } & {
109
- transforms: {
110
- toClient: (dbValue: string) => string;
111
- toDb: (clientValue: string) => string;
112
- };
113
- };
114
- };
115
- };
116
- pets: {
117
- config: {
118
- sql: ({
119
- fromKey: string;
120
- toKey: () => any;
121
- schema: () => {
122
- _tableName: string;
123
- id: {
124
- config: {
125
- sql: {
126
- type: "int";
127
- pk: true;
128
- };
129
- zodSqlSchema: import("zod").ZodNumber;
130
- zodNewSchema: import("zod").ZodNumber;
131
- initialValue: string;
132
- zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
133
- zodValidationSchema: import("zod").ZodString;
134
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
135
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
136
- } & {
137
- transforms: {
138
- toClient: (dbValue: number) => number;
139
- toDb: (clientValue: number) => number;
140
- };
141
- };
142
- };
143
- name: import("..").Builder<"sql", {
144
- type: "varchar";
145
- length: number;
146
- }, import("zod").ZodString, import("zod").ZodString, string, import("zod").ZodString, import("zod").ZodString>;
147
- userId: {
148
- type: "reference";
149
- to: () => import("..").Builder<"sql", {
150
- type: "int";
151
- pk: true;
152
- }, import("zod").ZodNumber, import("zod").ZodNumber, number, import("zod").ZodNumber, import("zod").ZodNumber>;
153
- };
154
- fluffynessScale: {
155
- config: {
156
- sql: {
157
- type: "text";
158
- };
159
- zodSqlSchema: import("zod").ZodString;
160
- zodNewSchema: import("zod").ZodString;
161
- initialValue: string;
162
- zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
163
- zodValidationSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
164
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
165
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
166
- } & {
167
- transforms: {
168
- toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
169
- toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
170
- };
171
- };
172
- };
173
- favourite: {
174
- config: {
175
- sql: {
176
- type: "int";
177
- };
178
- zodSqlSchema: import("zod").ZodNumber;
179
- zodNewSchema: import("zod").ZodNumber;
180
- initialValue: number;
181
- zodClientSchema: import("zod").ZodBoolean;
182
- zodValidationSchema: import("zod").ZodBoolean;
183
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
184
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
185
- } & {
186
- transforms: {
187
- toClient: (dbValue: number) => boolean;
188
- toDb: (clientValue: boolean) => number;
189
- };
190
- };
191
- };
192
- };
193
- defaultCount?: number;
194
- } & {
195
- type: "hasMany";
196
- }) | ({
197
- fromKey: string;
198
- toKey: () => any;
199
- schema: () => {
200
- _tableName: string;
201
- id: {
202
- config: {
203
- sql: {
204
- type: "int";
205
- pk: true;
206
- };
207
- zodSqlSchema: import("zod").ZodNumber;
208
- zodNewSchema: import("zod").ZodNumber;
209
- initialValue: string;
210
- zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
211
- zodValidationSchema: import("zod").ZodString;
212
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
213
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
214
- } & {
215
- transforms: {
216
- toClient: (dbValue: number) => number;
217
- toDb: (clientValue: number) => number;
218
- };
219
- };
220
- };
221
- name: import("..").Builder<"sql", {
222
- type: "varchar";
223
- length: number;
224
- }, import("zod").ZodString, import("zod").ZodString, string, import("zod").ZodString, import("zod").ZodString>;
225
- userId: {
226
- type: "reference";
227
- to: () => import("..").Builder<"sql", {
228
- type: "int";
229
- pk: true;
230
- }, import("zod").ZodNumber, import("zod").ZodNumber, number, import("zod").ZodNumber, import("zod").ZodNumber>;
231
- };
232
- fluffynessScale: {
233
- config: {
234
- sql: {
235
- type: "text";
236
- };
237
- zodSqlSchema: import("zod").ZodString;
238
- zodNewSchema: import("zod").ZodString;
239
- initialValue: string;
240
- zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
241
- zodValidationSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
242
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
243
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
244
- } & {
245
- transforms: {
246
- toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
247
- toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
248
- };
249
- };
250
- };
251
- favourite: {
252
- config: {
253
- sql: {
254
- type: "int";
255
- };
256
- zodSqlSchema: import("zod").ZodNumber;
257
- zodNewSchema: import("zod").ZodNumber;
258
- initialValue: number;
259
- zodClientSchema: import("zod").ZodBoolean;
260
- zodValidationSchema: import("zod").ZodBoolean;
261
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
262
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
263
- } & {
264
- transforms: {
265
- toClient: (dbValue: number) => boolean;
266
- toDb: (clientValue: boolean) => number;
267
- };
268
- };
269
- };
270
- };
271
- defaultCount?: number;
272
- } & {
273
- type: "hasOne";
274
- }) | ({
275
- fromKey: string;
276
- toKey: () => any;
277
- schema: () => {
278
- _tableName: string;
279
- id: {
280
- config: {
281
- sql: {
282
- type: "int";
283
- pk: true;
284
- };
285
- zodSqlSchema: import("zod").ZodNumber;
286
- zodNewSchema: import("zod").ZodNumber;
287
- initialValue: string;
288
- zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
289
- zodValidationSchema: import("zod").ZodString;
290
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
291
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
292
- } & {
293
- transforms: {
294
- toClient: (dbValue: number) => number;
295
- toDb: (clientValue: number) => number;
296
- };
297
- };
298
- };
299
- name: import("..").Builder<"sql", {
300
- type: "varchar";
301
- length: number;
302
- }, import("zod").ZodString, import("zod").ZodString, string, import("zod").ZodString, import("zod").ZodString>;
303
- userId: {
304
- type: "reference";
305
- to: () => import("..").Builder<"sql", {
306
- type: "int";
307
- pk: true;
308
- }, import("zod").ZodNumber, import("zod").ZodNumber, number, import("zod").ZodNumber, import("zod").ZodNumber>;
309
- };
310
- fluffynessScale: {
311
- config: {
312
- sql: {
313
- type: "text";
314
- };
315
- zodSqlSchema: import("zod").ZodString;
316
- zodNewSchema: import("zod").ZodString;
317
- initialValue: string;
318
- zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
319
- zodValidationSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
320
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
321
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
322
- } & {
323
- transforms: {
324
- toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
325
- toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
326
- };
327
- };
328
- };
329
- favourite: {
330
- config: {
331
- sql: {
332
- type: "int";
333
- };
334
- zodSqlSchema: import("zod").ZodNumber;
335
- zodNewSchema: import("zod").ZodNumber;
336
- initialValue: number;
337
- zodClientSchema: import("zod").ZodBoolean;
338
- zodValidationSchema: import("zod").ZodBoolean;
339
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
340
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
341
- } & {
342
- transforms: {
343
- toClient: (dbValue: number) => boolean;
344
- toDb: (clientValue: boolean) => number;
345
- };
346
- };
347
- };
348
- };
349
- defaultCount?: number;
350
- } & {
351
- type: "belongsTo";
352
- }) | ({
353
- fromKey: string;
354
- toKey: () => any;
355
- schema: () => {
356
- _tableName: string;
357
- id: {
358
- config: {
359
- sql: {
360
- type: "int";
361
- pk: true;
362
- };
363
- zodSqlSchema: import("zod").ZodNumber;
364
- zodNewSchema: import("zod").ZodNumber;
365
- initialValue: string;
366
- zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
367
- zodValidationSchema: import("zod").ZodString;
368
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
369
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
370
- } & {
371
- transforms: {
372
- toClient: (dbValue: number) => number;
373
- toDb: (clientValue: number) => number;
374
- };
375
- };
376
- };
377
- name: import("..").Builder<"sql", {
378
- type: "varchar";
379
- length: number;
380
- }, import("zod").ZodString, import("zod").ZodString, string, import("zod").ZodString, import("zod").ZodString>;
381
- userId: {
382
- type: "reference";
383
- to: () => import("..").Builder<"sql", {
384
- type: "int";
385
- pk: true;
386
- }, import("zod").ZodNumber, import("zod").ZodNumber, number, import("zod").ZodNumber, import("zod").ZodNumber>;
387
- };
388
- fluffynessScale: {
389
- config: {
390
- sql: {
391
- type: "text";
392
- };
393
- zodSqlSchema: import("zod").ZodString;
394
- zodNewSchema: import("zod").ZodString;
395
- initialValue: string;
396
- zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
397
- zodValidationSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
398
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
399
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
400
- } & {
401
- transforms: {
402
- toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
403
- toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
404
- };
405
- };
406
- };
407
- favourite: {
408
- config: {
409
- sql: {
410
- type: "int";
411
- };
412
- zodSqlSchema: import("zod").ZodNumber;
413
- zodNewSchema: import("zod").ZodNumber;
414
- initialValue: number;
415
- zodClientSchema: import("zod").ZodBoolean;
416
- zodValidationSchema: import("zod").ZodBoolean;
417
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
418
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
419
- } & {
420
- transforms: {
421
- toClient: (dbValue: number) => boolean;
422
- toDb: (clientValue: boolean) => number;
423
- };
424
- };
425
- };
426
- };
427
- defaultCount?: number;
428
- } & {
429
- type: "manyToMany";
430
- });
431
- zodSqlSchema: import("zod").ZodArray<import("zod").ZodObject<{
432
- id: import("zod").ZodNumber;
433
- name: import("zod").ZodString;
434
- userId: import("zod").ZodAny;
435
- fluffynessScale: import("zod").ZodString;
436
- favourite: import("zod").ZodNumber;
437
- }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
438
- name: string;
439
- id: number;
440
- fluffynessScale: string;
441
- favourite: number;
442
- userId?: any;
443
- }, {
444
- name: string;
445
- id: number;
446
- fluffynessScale: string;
447
- favourite: number;
448
- userId?: any;
449
- }>, "many">;
450
- zodNewSchema: import("zod").ZodArray<import("zod").ZodObject<{
451
- id: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
452
- name: import("zod").ZodString;
453
- userId: import("zod").ZodAny;
454
- fluffynessScale: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
455
- favourite: import("zod").ZodBoolean;
456
- }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
457
- name: string;
458
- id: number;
459
- fluffynessScale: ("bald" | "fuzzy" | "fluffy" | "poof")[];
460
- favourite: boolean;
461
- userId?: any;
462
- }, {
463
- name: string;
464
- id: number;
465
- fluffynessScale: ("bald" | "fuzzy" | "fluffy" | "poof")[];
466
- favourite: boolean;
467
- userId?: any;
468
- }>, "many">;
469
- initialValue: any[];
470
- zodClientSchema: import("zod").ZodArray<import("zod").ZodObject<{
471
- id: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
472
- name: import("zod").ZodString;
473
- userId: import("zod").ZodAny;
474
- fluffynessScale: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
475
- favourite: import("zod").ZodBoolean;
476
- }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
477
- name: string;
478
- id: number;
479
- fluffynessScale: ("bald" | "fuzzy" | "fluffy" | "poof")[];
480
- favourite: boolean;
481
- userId?: any;
482
- }, {
483
- name: string;
484
- id: number;
485
- fluffynessScale: ("bald" | "fuzzy" | "fluffy" | "poof")[];
486
- favourite: boolean;
487
- userId?: any;
488
- }>, "many">;
489
- zodValidationSchema: import("zod").ZodArray<import("zod").ZodObject<{
490
- id: import("zod").ZodNumber;
491
- name: import("zod").ZodString;
492
- userId: import("zod").ZodAny;
493
- fluffynessScale: import("zod").ZodString;
494
- favourite: import("zod").ZodNumber;
495
- }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
496
- name: string;
497
- id: number;
498
- fluffynessScale: string;
499
- favourite: number;
500
- userId?: any;
501
- }, {
502
- name: string;
503
- id: number;
504
- fluffynessScale: string;
505
- favourite: number;
506
- userId?: any;
507
- }>, "many">;
508
- };
509
- transform: (transforms: {
510
- toClient: (dbValue: {
511
- name: string;
512
- id: number;
513
- fluffynessScale: string;
514
- favourite: number;
515
- userId?: any;
516
- }[]) => {
517
- name: string;
518
- id: number;
519
- fluffynessScale: ("bald" | "fuzzy" | "fluffy" | "poof")[];
520
- favourite: boolean;
521
- userId?: any;
522
- }[];
523
- toDb: (clientValue: {
524
- name: string;
525
- id: number;
526
- fluffynessScale: ("bald" | "fuzzy" | "fluffy" | "poof")[];
527
- favourite: boolean;
528
- userId?: any;
529
- }[]) => {
530
- name: string;
531
- id: number;
532
- fluffynessScale: string;
533
- favourite: number;
534
- userId?: any;
535
- }[];
536
- }) => {
537
- config: {
538
- sql: ({
539
- fromKey: string;
540
- toKey: () => any;
541
- schema: () => {
542
- _tableName: string;
543
- id: {
544
- config: {
545
- sql: {
546
- type: "int";
547
- pk: true;
548
- };
549
- zodSqlSchema: import("zod").ZodNumber;
550
- zodNewSchema: import("zod").ZodNumber;
551
- initialValue: string;
552
- zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
553
- zodValidationSchema: import("zod").ZodString;
554
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
555
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
556
- } & {
557
- transforms: {
558
- toClient: (dbValue: number) => number;
559
- toDb: (clientValue: number) => number;
560
- };
561
- };
562
- };
563
- name: import("..").Builder<"sql", {
564
- type: "varchar";
565
- length: number;
566
- }, import("zod").ZodString, import("zod").ZodString, string, import("zod").ZodString, import("zod").ZodString>;
567
- userId: {
568
- type: "reference";
569
- to: () => import("..").Builder<"sql", {
570
- type: "int";
571
- pk: true;
572
- }, import("zod").ZodNumber, import("zod").ZodNumber, number, import("zod").ZodNumber, import("zod").ZodNumber>;
573
- };
574
- fluffynessScale: {
575
- config: {
576
- sql: {
577
- type: "text";
578
- };
579
- zodSqlSchema: import("zod").ZodString;
580
- zodNewSchema: import("zod").ZodString;
581
- initialValue: string;
582
- zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
583
- zodValidationSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
584
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
585
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
586
- } & {
587
- transforms: {
588
- toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
589
- toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
590
- };
591
- };
592
- };
593
- favourite: {
594
- config: {
595
- sql: {
596
- type: "int";
597
- };
598
- zodSqlSchema: import("zod").ZodNumber;
599
- zodNewSchema: import("zod").ZodNumber;
600
- initialValue: number;
601
- zodClientSchema: import("zod").ZodBoolean;
602
- zodValidationSchema: import("zod").ZodBoolean;
603
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
604
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
605
- } & {
606
- transforms: {
607
- toClient: (dbValue: number) => boolean;
608
- toDb: (clientValue: boolean) => number;
609
- };
610
- };
611
- };
612
- };
613
- defaultCount?: number;
614
- } & {
615
- type: "hasMany";
616
- }) | ({
617
- fromKey: string;
618
- toKey: () => any;
619
- schema: () => {
620
- _tableName: string;
621
- id: {
622
- config: {
623
- sql: {
624
- type: "int";
625
- pk: true;
626
- };
627
- zodSqlSchema: import("zod").ZodNumber;
628
- zodNewSchema: import("zod").ZodNumber;
629
- initialValue: string;
630
- zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
631
- zodValidationSchema: import("zod").ZodString;
632
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
633
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
634
- } & {
635
- transforms: {
636
- toClient: (dbValue: number) => number;
637
- toDb: (clientValue: number) => number;
638
- };
639
- };
640
- };
641
- name: import("..").Builder<"sql", {
642
- type: "varchar";
643
- length: number;
644
- }, import("zod").ZodString, import("zod").ZodString, string, import("zod").ZodString, import("zod").ZodString>;
645
- userId: {
646
- type: "reference";
647
- to: () => import("..").Builder<"sql", {
648
- type: "int";
649
- pk: true;
650
- }, import("zod").ZodNumber, import("zod").ZodNumber, number, import("zod").ZodNumber, import("zod").ZodNumber>;
651
- };
652
- fluffynessScale: {
653
- config: {
654
- sql: {
655
- type: "text";
656
- };
657
- zodSqlSchema: import("zod").ZodString;
658
- zodNewSchema: import("zod").ZodString;
659
- initialValue: string;
660
- zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
661
- zodValidationSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
662
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
663
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
664
- } & {
665
- transforms: {
666
- toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
667
- toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
668
- };
669
- };
670
- };
671
- favourite: {
672
- config: {
673
- sql: {
674
- type: "int";
675
- };
676
- zodSqlSchema: import("zod").ZodNumber;
677
- zodNewSchema: import("zod").ZodNumber;
678
- initialValue: number;
679
- zodClientSchema: import("zod").ZodBoolean;
680
- zodValidationSchema: import("zod").ZodBoolean;
681
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
682
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
683
- } & {
684
- transforms: {
685
- toClient: (dbValue: number) => boolean;
686
- toDb: (clientValue: boolean) => number;
687
- };
688
- };
689
- };
690
- };
691
- defaultCount?: number;
692
- } & {
693
- type: "hasOne";
694
- }) | ({
695
- fromKey: string;
696
- toKey: () => any;
697
- schema: () => {
698
- _tableName: string;
699
- id: {
700
- config: {
701
- sql: {
702
- type: "int";
703
- pk: true;
704
- };
705
- zodSqlSchema: import("zod").ZodNumber;
706
- zodNewSchema: import("zod").ZodNumber;
707
- initialValue: string;
708
- zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
709
- zodValidationSchema: import("zod").ZodString;
710
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
711
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
712
- } & {
713
- transforms: {
714
- toClient: (dbValue: number) => number;
715
- toDb: (clientValue: number) => number;
716
- };
717
- };
718
- };
719
- name: import("..").Builder<"sql", {
720
- type: "varchar";
721
- length: number;
722
- }, import("zod").ZodString, import("zod").ZodString, string, import("zod").ZodString, import("zod").ZodString>;
723
- userId: {
724
- type: "reference";
725
- to: () => import("..").Builder<"sql", {
726
- type: "int";
727
- pk: true;
728
- }, import("zod").ZodNumber, import("zod").ZodNumber, number, import("zod").ZodNumber, import("zod").ZodNumber>;
729
- };
730
- fluffynessScale: {
731
- config: {
732
- sql: {
733
- type: "text";
734
- };
735
- zodSqlSchema: import("zod").ZodString;
736
- zodNewSchema: import("zod").ZodString;
737
- initialValue: string;
738
- zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
739
- zodValidationSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
740
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
741
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
742
- } & {
743
- transforms: {
744
- toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
745
- toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
746
- };
747
- };
748
- };
749
- favourite: {
750
- config: {
751
- sql: {
752
- type: "int";
753
- };
754
- zodSqlSchema: import("zod").ZodNumber;
755
- zodNewSchema: import("zod").ZodNumber;
756
- initialValue: number;
757
- zodClientSchema: import("zod").ZodBoolean;
758
- zodValidationSchema: import("zod").ZodBoolean;
759
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
760
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
761
- } & {
762
- transforms: {
763
- toClient: (dbValue: number) => boolean;
764
- toDb: (clientValue: boolean) => number;
765
- };
766
- };
767
- };
768
- };
769
- defaultCount?: number;
770
- } & {
771
- type: "belongsTo";
772
- }) | ({
773
- fromKey: string;
774
- toKey: () => any;
775
- schema: () => {
776
- _tableName: string;
777
- id: {
778
- config: {
779
- sql: {
780
- type: "int";
781
- pk: true;
782
- };
783
- zodSqlSchema: import("zod").ZodNumber;
784
- zodNewSchema: import("zod").ZodNumber;
785
- initialValue: string;
786
- zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
787
- zodValidationSchema: import("zod").ZodString;
788
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
789
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
790
- } & {
791
- transforms: {
792
- toClient: (dbValue: number) => number;
793
- toDb: (clientValue: number) => number;
794
- };
795
- };
796
- };
797
- name: import("..").Builder<"sql", {
798
- type: "varchar";
799
- length: number;
800
- }, import("zod").ZodString, import("zod").ZodString, string, import("zod").ZodString, import("zod").ZodString>;
801
- userId: {
802
- type: "reference";
803
- to: () => import("..").Builder<"sql", {
804
- type: "int";
805
- pk: true;
806
- }, import("zod").ZodNumber, import("zod").ZodNumber, number, import("zod").ZodNumber, import("zod").ZodNumber>;
807
- };
808
- fluffynessScale: {
809
- config: {
810
- sql: {
811
- type: "text";
812
- };
813
- zodSqlSchema: import("zod").ZodString;
814
- zodNewSchema: import("zod").ZodString;
815
- initialValue: string;
816
- zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
817
- zodValidationSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
818
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
819
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
820
- } & {
821
- transforms: {
822
- toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
823
- toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
824
- };
825
- };
826
- };
827
- favourite: {
828
- config: {
829
- sql: {
830
- type: "int";
831
- };
832
- zodSqlSchema: import("zod").ZodNumber;
833
- zodNewSchema: import("zod").ZodNumber;
834
- initialValue: number;
835
- zodClientSchema: import("zod").ZodBoolean;
836
- zodValidationSchema: import("zod").ZodBoolean;
837
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
838
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
839
- } & {
840
- transforms: {
841
- toClient: (dbValue: number) => boolean;
842
- toDb: (clientValue: boolean) => number;
843
- };
844
- };
845
- };
846
- };
847
- defaultCount?: number;
848
- } & {
849
- type: "manyToMany";
850
- });
851
- zodSqlSchema: import("zod").ZodArray<import("zod").ZodObject<{
852
- id: import("zod").ZodNumber;
853
- name: import("zod").ZodString;
854
- userId: import("zod").ZodAny;
855
- fluffynessScale: import("zod").ZodString;
856
- favourite: import("zod").ZodNumber;
857
- }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
858
- name: string;
859
- id: number;
860
- fluffynessScale: string;
861
- favourite: number;
862
- userId?: any;
863
- }, {
864
- name: string;
865
- id: number;
866
- fluffynessScale: string;
867
- favourite: number;
868
- userId?: any;
869
- }>, "many">;
870
- zodNewSchema: import("zod").ZodArray<import("zod").ZodObject<{
871
- id: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
872
- name: import("zod").ZodString;
873
- userId: import("zod").ZodAny;
874
- fluffynessScale: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
875
- favourite: import("zod").ZodBoolean;
876
- }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
877
- name: string;
878
- id: number;
879
- fluffynessScale: ("bald" | "fuzzy" | "fluffy" | "poof")[];
880
- favourite: boolean;
881
- userId?: any;
882
- }, {
883
- name: string;
884
- id: number;
885
- fluffynessScale: ("bald" | "fuzzy" | "fluffy" | "poof")[];
886
- favourite: boolean;
887
- userId?: any;
888
- }>, "many">;
889
- initialValue: any[];
890
- zodClientSchema: import("zod").ZodArray<import("zod").ZodObject<{
891
- id: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
892
- name: import("zod").ZodString;
893
- userId: import("zod").ZodAny;
894
- fluffynessScale: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
895
- favourite: import("zod").ZodBoolean;
896
- }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
897
- name: string;
898
- id: number;
899
- fluffynessScale: ("bald" | "fuzzy" | "fluffy" | "poof")[];
900
- favourite: boolean;
901
- userId?: any;
902
- }, {
903
- name: string;
904
- id: number;
905
- fluffynessScale: ("bald" | "fuzzy" | "fluffy" | "poof")[];
906
- favourite: boolean;
907
- userId?: any;
908
- }>, "many">;
909
- zodValidationSchema: import("zod").ZodArray<import("zod").ZodObject<{
910
- id: import("zod").ZodNumber;
911
- name: import("zod").ZodString;
912
- userId: import("zod").ZodAny;
913
- fluffynessScale: import("zod").ZodString;
914
- favourite: import("zod").ZodNumber;
915
- }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
916
- name: string;
917
- id: number;
918
- fluffynessScale: string;
919
- favourite: number;
920
- userId?: any;
921
- }, {
922
- name: string;
923
- id: number;
924
- fluffynessScale: string;
925
- favourite: number;
926
- userId?: any;
927
- }>, "many">;
928
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
929
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
930
- } & {
931
- transforms: {
932
- toClient: (dbValue: {
933
- name: string;
934
- id: number;
935
- fluffynessScale: string;
936
- favourite: number;
937
- userId?: any;
938
- }[]) => {
939
- name: string;
940
- id: number;
941
- fluffynessScale: ("bald" | "fuzzy" | "fluffy" | "poof")[];
942
- favourite: boolean;
943
- userId?: any;
944
- }[];
945
- toDb: (clientValue: {
946
- name: string;
947
- id: number;
948
- fluffynessScale: ("bald" | "fuzzy" | "fluffy" | "poof")[];
949
- favourite: boolean;
950
- userId?: any;
951
- }[]) => {
952
- name: string;
953
- id: number;
954
- fluffynessScale: string;
955
- favourite: number;
956
- userId?: any;
957
- }[];
958
- };
959
- };
960
- };
961
- };
962
- };
963
- pet: {
964
- _tableName: string;
965
- id: {
966
- config: {
967
- sql: {
968
- type: "int";
969
- pk: true;
970
- };
971
- zodSqlSchema: import("zod").ZodNumber;
972
- zodNewSchema: import("zod").ZodNumber;
973
- initialValue: string;
974
- zodClientSchema: import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNumber]>;
975
- zodValidationSchema: import("zod").ZodString;
976
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
977
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
978
- } & {
979
- transforms: {
980
- toClient: (dbValue: number) => number;
981
- toDb: (clientValue: number) => number;
982
- };
983
- };
984
- };
985
- name: import("..").Builder<"sql", {
986
- type: "varchar";
987
- length: number;
988
- }, import("zod").ZodString, import("zod").ZodString, string, import("zod").ZodString, import("zod").ZodString>;
989
- userId: {
990
- type: "reference";
991
- to: () => import("..").Builder<"sql", {
992
- type: "int";
993
- pk: true;
994
- }, import("zod").ZodNumber, import("zod").ZodNumber, number, import("zod").ZodNumber, import("zod").ZodNumber>;
995
- };
996
- fluffynessScale: {
997
- config: {
998
- sql: {
999
- type: "text";
1000
- };
1001
- zodSqlSchema: import("zod").ZodString;
1002
- zodNewSchema: import("zod").ZodString;
1003
- initialValue: string;
1004
- zodClientSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
1005
- zodValidationSchema: import("zod").ZodArray<import("zod").ZodEnum<["bald", "fuzzy", "fluffy", "poof"]>, "many">;
1006
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
1007
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
1008
- } & {
1009
- transforms: {
1010
- toClient: (dbValue: string) => ("bald" | "fuzzy" | "fluffy" | "poof")[];
1011
- toDb: (clientValue: ("bald" | "fuzzy" | "fluffy" | "poof")[]) => string;
1012
- };
1013
- };
1014
- };
1015
- favourite: {
1016
- config: {
1017
- sql: {
1018
- type: "int";
1019
- };
1020
- zodSqlSchema: import("zod").ZodNumber;
1021
- zodNewSchema: import("zod").ZodNumber;
1022
- initialValue: number;
1023
- zodClientSchema: import("zod").ZodBoolean;
1024
- zodValidationSchema: import("zod").ZodBoolean;
1025
- clientTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
1026
- validationTransform?: (schema: import("zod").ZodTypeAny) => import("zod").ZodTypeAny;
1027
- } & {
1028
- transforms: {
1029
- toClient: (dbValue: number) => boolean;
1030
- toDb: (clientValue: boolean) => number;
1031
- };
1032
- };
1033
- };
1034
- };
1035
- };
1036
- export { schemas };