@freehour/supabase-core 1.0.0

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