@foundrynorth/flux-schema 1.18.0 → 1.19.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.
- package/dist/schema.d.ts +1039 -236
- package/dist/schema.d.ts.map +1 -1
- package/dist/schema.js +164 -0
- package/dist/schema.js.map +1 -1
- package/package.json +1 -1
package/dist/schema.d.ts
CHANGED
|
@@ -28152,13 +28152,19 @@ export declare const fluxTapclicksPacing: import("drizzle-orm/pg-core").PgTableW
|
|
|
28152
28152
|
}>;
|
|
28153
28153
|
export type FluxTapclicksPacing = typeof fluxTapclicksPacing.$inferSelect;
|
|
28154
28154
|
export type NewFluxTapclicksPacing = typeof fluxTapclicksPacing.$inferInsert;
|
|
28155
|
-
|
|
28156
|
-
|
|
28155
|
+
/**
|
|
28156
|
+
* TapClicks Full Order Archive — Complete raw snapshots of every order
|
|
28157
|
+
* including nested line_items, attributes, flights, and task_attributes.
|
|
28158
|
+
* Used as migration reference for Compass and historical audit trail.
|
|
28159
|
+
* Key fields extracted for indexing; full detail preserved in raw_json.
|
|
28160
|
+
*/
|
|
28161
|
+
export declare const fluxTapclicksArchive: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
28162
|
+
name: "flux_tapclicks_archive";
|
|
28157
28163
|
schema: undefined;
|
|
28158
28164
|
columns: {
|
|
28159
28165
|
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
28160
28166
|
name: "id";
|
|
28161
|
-
tableName: "
|
|
28167
|
+
tableName: "flux_tapclicks_archive";
|
|
28162
28168
|
dataType: "number";
|
|
28163
28169
|
columnType: "PgSerial";
|
|
28164
28170
|
data: number;
|
|
@@ -28173,14 +28179,31 @@ export declare const fluxCreativeDeliveryCorrelation: import("drizzle-orm/pg-cor
|
|
|
28173
28179
|
identity: undefined;
|
|
28174
28180
|
generated: undefined;
|
|
28175
28181
|
}, {}, {}>;
|
|
28176
|
-
|
|
28177
|
-
name: "
|
|
28178
|
-
tableName: "
|
|
28182
|
+
tapId: import("drizzle-orm/pg-core").PgColumn<{
|
|
28183
|
+
name: "tap_id";
|
|
28184
|
+
tableName: "flux_tapclicks_archive";
|
|
28185
|
+
dataType: "number";
|
|
28186
|
+
columnType: "PgInteger";
|
|
28187
|
+
data: number;
|
|
28188
|
+
driverParam: string | number;
|
|
28189
|
+
notNull: true;
|
|
28190
|
+
hasDefault: false;
|
|
28191
|
+
isPrimaryKey: false;
|
|
28192
|
+
isAutoincrement: false;
|
|
28193
|
+
hasRuntimeDefault: false;
|
|
28194
|
+
enumValues: undefined;
|
|
28195
|
+
baseColumn: never;
|
|
28196
|
+
identity: undefined;
|
|
28197
|
+
generated: undefined;
|
|
28198
|
+
}, {}, {}>;
|
|
28199
|
+
orderName: import("drizzle-orm/pg-core").PgColumn<{
|
|
28200
|
+
name: "order_name";
|
|
28201
|
+
tableName: "flux_tapclicks_archive";
|
|
28179
28202
|
dataType: "string";
|
|
28180
28203
|
columnType: "PgText";
|
|
28181
28204
|
data: string;
|
|
28182
28205
|
driverParam: string;
|
|
28183
|
-
notNull:
|
|
28206
|
+
notNull: false;
|
|
28184
28207
|
hasDefault: false;
|
|
28185
28208
|
isPrimaryKey: false;
|
|
28186
28209
|
isAutoincrement: false;
|
|
@@ -28190,14 +28213,14 @@ export declare const fluxCreativeDeliveryCorrelation: import("drizzle-orm/pg-cor
|
|
|
28190
28213
|
identity: undefined;
|
|
28191
28214
|
generated: undefined;
|
|
28192
28215
|
}, {}, {}>;
|
|
28193
|
-
|
|
28194
|
-
name: "
|
|
28195
|
-
tableName: "
|
|
28216
|
+
clientName: import("drizzle-orm/pg-core").PgColumn<{
|
|
28217
|
+
name: "client_name";
|
|
28218
|
+
tableName: "flux_tapclicks_archive";
|
|
28196
28219
|
dataType: "string";
|
|
28197
28220
|
columnType: "PgText";
|
|
28198
28221
|
data: string;
|
|
28199
28222
|
driverParam: string;
|
|
28200
|
-
notNull:
|
|
28223
|
+
notNull: false;
|
|
28201
28224
|
hasDefault: false;
|
|
28202
28225
|
isPrimaryKey: false;
|
|
28203
28226
|
isAutoincrement: false;
|
|
@@ -28207,14 +28230,14 @@ export declare const fluxCreativeDeliveryCorrelation: import("drizzle-orm/pg-cor
|
|
|
28207
28230
|
identity: undefined;
|
|
28208
28231
|
generated: undefined;
|
|
28209
28232
|
}, {}, {}>;
|
|
28210
|
-
|
|
28211
|
-
name: "
|
|
28212
|
-
tableName: "
|
|
28233
|
+
clientTapId: import("drizzle-orm/pg-core").PgColumn<{
|
|
28234
|
+
name: "client_tap_id";
|
|
28235
|
+
tableName: "flux_tapclicks_archive";
|
|
28213
28236
|
dataType: "number";
|
|
28214
28237
|
columnType: "PgInteger";
|
|
28215
28238
|
data: number;
|
|
28216
28239
|
driverParam: string | number;
|
|
28217
|
-
notNull:
|
|
28240
|
+
notNull: false;
|
|
28218
28241
|
hasDefault: false;
|
|
28219
28242
|
isPrimaryKey: false;
|
|
28220
28243
|
isAutoincrement: false;
|
|
@@ -28224,9 +28247,77 @@ export declare const fluxCreativeDeliveryCorrelation: import("drizzle-orm/pg-cor
|
|
|
28224
28247
|
identity: undefined;
|
|
28225
28248
|
generated: undefined;
|
|
28226
28249
|
}, {}, {}>;
|
|
28227
|
-
|
|
28228
|
-
name: "
|
|
28229
|
-
tableName: "
|
|
28250
|
+
salesRep: import("drizzle-orm/pg-core").PgColumn<{
|
|
28251
|
+
name: "sales_rep";
|
|
28252
|
+
tableName: "flux_tapclicks_archive";
|
|
28253
|
+
dataType: "string";
|
|
28254
|
+
columnType: "PgText";
|
|
28255
|
+
data: string;
|
|
28256
|
+
driverParam: string;
|
|
28257
|
+
notNull: false;
|
|
28258
|
+
hasDefault: false;
|
|
28259
|
+
isPrimaryKey: false;
|
|
28260
|
+
isAutoincrement: false;
|
|
28261
|
+
hasRuntimeDefault: false;
|
|
28262
|
+
enumValues: [string, ...string[]];
|
|
28263
|
+
baseColumn: never;
|
|
28264
|
+
identity: undefined;
|
|
28265
|
+
generated: undefined;
|
|
28266
|
+
}, {}, {}>;
|
|
28267
|
+
status: import("drizzle-orm/pg-core").PgColumn<{
|
|
28268
|
+
name: "status";
|
|
28269
|
+
tableName: "flux_tapclicks_archive";
|
|
28270
|
+
dataType: "string";
|
|
28271
|
+
columnType: "PgText";
|
|
28272
|
+
data: string;
|
|
28273
|
+
driverParam: string;
|
|
28274
|
+
notNull: false;
|
|
28275
|
+
hasDefault: false;
|
|
28276
|
+
isPrimaryKey: false;
|
|
28277
|
+
isAutoincrement: false;
|
|
28278
|
+
hasRuntimeDefault: false;
|
|
28279
|
+
enumValues: [string, ...string[]];
|
|
28280
|
+
baseColumn: never;
|
|
28281
|
+
identity: undefined;
|
|
28282
|
+
generated: undefined;
|
|
28283
|
+
}, {}, {}>;
|
|
28284
|
+
workflowStep: import("drizzle-orm/pg-core").PgColumn<{
|
|
28285
|
+
name: "workflow_step";
|
|
28286
|
+
tableName: "flux_tapclicks_archive";
|
|
28287
|
+
dataType: "string";
|
|
28288
|
+
columnType: "PgText";
|
|
28289
|
+
data: string;
|
|
28290
|
+
driverParam: string;
|
|
28291
|
+
notNull: false;
|
|
28292
|
+
hasDefault: false;
|
|
28293
|
+
isPrimaryKey: false;
|
|
28294
|
+
isAutoincrement: false;
|
|
28295
|
+
hasRuntimeDefault: false;
|
|
28296
|
+
enumValues: [string, ...string[]];
|
|
28297
|
+
baseColumn: never;
|
|
28298
|
+
identity: undefined;
|
|
28299
|
+
generated: undefined;
|
|
28300
|
+
}, {}, {}>;
|
|
28301
|
+
orderType: import("drizzle-orm/pg-core").PgColumn<{
|
|
28302
|
+
name: "order_type";
|
|
28303
|
+
tableName: "flux_tapclicks_archive";
|
|
28304
|
+
dataType: "string";
|
|
28305
|
+
columnType: "PgText";
|
|
28306
|
+
data: string;
|
|
28307
|
+
driverParam: string;
|
|
28308
|
+
notNull: false;
|
|
28309
|
+
hasDefault: false;
|
|
28310
|
+
isPrimaryKey: false;
|
|
28311
|
+
isAutoincrement: false;
|
|
28312
|
+
hasRuntimeDefault: false;
|
|
28313
|
+
enumValues: [string, ...string[]];
|
|
28314
|
+
baseColumn: never;
|
|
28315
|
+
identity: undefined;
|
|
28316
|
+
generated: undefined;
|
|
28317
|
+
}, {}, {}>;
|
|
28318
|
+
totalBudget: import("drizzle-orm/pg-core").PgColumn<{
|
|
28319
|
+
name: "total_budget";
|
|
28320
|
+
tableName: "flux_tapclicks_archive";
|
|
28230
28321
|
dataType: "string";
|
|
28231
28322
|
columnType: "PgNumeric";
|
|
28232
28323
|
data: string;
|
|
@@ -28241,11 +28332,11 @@ export declare const fluxCreativeDeliveryCorrelation: import("drizzle-orm/pg-cor
|
|
|
28241
28332
|
identity: undefined;
|
|
28242
28333
|
generated: undefined;
|
|
28243
28334
|
}, {}, {}>;
|
|
28244
|
-
|
|
28245
|
-
name: "
|
|
28246
|
-
tableName: "
|
|
28335
|
+
startDate: import("drizzle-orm/pg-core").PgColumn<{
|
|
28336
|
+
name: "start_date";
|
|
28337
|
+
tableName: "flux_tapclicks_archive";
|
|
28247
28338
|
dataType: "string";
|
|
28248
|
-
columnType: "
|
|
28339
|
+
columnType: "PgDateString";
|
|
28249
28340
|
data: string;
|
|
28250
28341
|
driverParam: string;
|
|
28251
28342
|
notNull: false;
|
|
@@ -28258,11 +28349,11 @@ export declare const fluxCreativeDeliveryCorrelation: import("drizzle-orm/pg-cor
|
|
|
28258
28349
|
identity: undefined;
|
|
28259
28350
|
generated: undefined;
|
|
28260
28351
|
}, {}, {}>;
|
|
28261
|
-
|
|
28262
|
-
name: "
|
|
28263
|
-
tableName: "
|
|
28352
|
+
endDate: import("drizzle-orm/pg-core").PgColumn<{
|
|
28353
|
+
name: "end_date";
|
|
28354
|
+
tableName: "flux_tapclicks_archive";
|
|
28264
28355
|
dataType: "string";
|
|
28265
|
-
columnType: "
|
|
28356
|
+
columnType: "PgDateString";
|
|
28266
28357
|
data: string;
|
|
28267
28358
|
driverParam: string;
|
|
28268
28359
|
notNull: false;
|
|
@@ -28275,9 +28366,26 @@ export declare const fluxCreativeDeliveryCorrelation: import("drizzle-orm/pg-cor
|
|
|
28275
28366
|
identity: undefined;
|
|
28276
28367
|
generated: undefined;
|
|
28277
28368
|
}, {}, {}>;
|
|
28278
|
-
|
|
28279
|
-
name: "
|
|
28280
|
-
tableName: "
|
|
28369
|
+
lineItemCount: import("drizzle-orm/pg-core").PgColumn<{
|
|
28370
|
+
name: "line_item_count";
|
|
28371
|
+
tableName: "flux_tapclicks_archive";
|
|
28372
|
+
dataType: "number";
|
|
28373
|
+
columnType: "PgInteger";
|
|
28374
|
+
data: number;
|
|
28375
|
+
driverParam: string | number;
|
|
28376
|
+
notNull: false;
|
|
28377
|
+
hasDefault: false;
|
|
28378
|
+
isPrimaryKey: false;
|
|
28379
|
+
isAutoincrement: false;
|
|
28380
|
+
hasRuntimeDefault: false;
|
|
28381
|
+
enumValues: undefined;
|
|
28382
|
+
baseColumn: never;
|
|
28383
|
+
identity: undefined;
|
|
28384
|
+
generated: undefined;
|
|
28385
|
+
}, {}, {}>;
|
|
28386
|
+
dfpOrderId: import("drizzle-orm/pg-core").PgColumn<{
|
|
28387
|
+
name: "dfp_order_id";
|
|
28388
|
+
tableName: "flux_tapclicks_archive";
|
|
28281
28389
|
dataType: "string";
|
|
28282
28390
|
columnType: "PgText";
|
|
28283
28391
|
data: string;
|
|
@@ -28292,13 +28400,30 @@ export declare const fluxCreativeDeliveryCorrelation: import("drizzle-orm/pg-cor
|
|
|
28292
28400
|
identity: undefined;
|
|
28293
28401
|
generated: undefined;
|
|
28294
28402
|
}, {}, {}>;
|
|
28295
|
-
|
|
28296
|
-
name: "
|
|
28297
|
-
tableName: "
|
|
28403
|
+
rawJson: import("drizzle-orm/pg-core").PgColumn<{
|
|
28404
|
+
name: "raw_json";
|
|
28405
|
+
tableName: "flux_tapclicks_archive";
|
|
28298
28406
|
dataType: "json";
|
|
28299
28407
|
columnType: "PgJsonb";
|
|
28300
28408
|
data: unknown;
|
|
28301
28409
|
driverParam: unknown;
|
|
28410
|
+
notNull: true;
|
|
28411
|
+
hasDefault: false;
|
|
28412
|
+
isPrimaryKey: false;
|
|
28413
|
+
isAutoincrement: false;
|
|
28414
|
+
hasRuntimeDefault: false;
|
|
28415
|
+
enumValues: undefined;
|
|
28416
|
+
baseColumn: never;
|
|
28417
|
+
identity: undefined;
|
|
28418
|
+
generated: undefined;
|
|
28419
|
+
}, {}, {}>;
|
|
28420
|
+
tapCreatedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
28421
|
+
name: "tap_created_at";
|
|
28422
|
+
tableName: "flux_tapclicks_archive";
|
|
28423
|
+
dataType: "date";
|
|
28424
|
+
columnType: "PgTimestamp";
|
|
28425
|
+
data: Date;
|
|
28426
|
+
driverParam: string;
|
|
28302
28427
|
notNull: false;
|
|
28303
28428
|
hasDefault: false;
|
|
28304
28429
|
isPrimaryKey: false;
|
|
@@ -28309,9 +28434,26 @@ export declare const fluxCreativeDeliveryCorrelation: import("drizzle-orm/pg-cor
|
|
|
28309
28434
|
identity: undefined;
|
|
28310
28435
|
generated: undefined;
|
|
28311
28436
|
}, {}, {}>;
|
|
28312
|
-
|
|
28313
|
-
name: "
|
|
28314
|
-
tableName: "
|
|
28437
|
+
tapUpdatedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
28438
|
+
name: "tap_updated_at";
|
|
28439
|
+
tableName: "flux_tapclicks_archive";
|
|
28440
|
+
dataType: "date";
|
|
28441
|
+
columnType: "PgTimestamp";
|
|
28442
|
+
data: Date;
|
|
28443
|
+
driverParam: string;
|
|
28444
|
+
notNull: false;
|
|
28445
|
+
hasDefault: false;
|
|
28446
|
+
isPrimaryKey: false;
|
|
28447
|
+
isAutoincrement: false;
|
|
28448
|
+
hasRuntimeDefault: false;
|
|
28449
|
+
enumValues: undefined;
|
|
28450
|
+
baseColumn: never;
|
|
28451
|
+
identity: undefined;
|
|
28452
|
+
generated: undefined;
|
|
28453
|
+
}, {}, {}>;
|
|
28454
|
+
archivedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
28455
|
+
name: "archived_at";
|
|
28456
|
+
tableName: "flux_tapclicks_archive";
|
|
28315
28457
|
dataType: "date";
|
|
28316
28458
|
columnType: "PgTimestamp";
|
|
28317
28459
|
data: Date;
|
|
@@ -28329,14 +28471,15 @@ export declare const fluxCreativeDeliveryCorrelation: import("drizzle-orm/pg-cor
|
|
|
28329
28471
|
};
|
|
28330
28472
|
dialect: "pg";
|
|
28331
28473
|
}>;
|
|
28332
|
-
export type
|
|
28333
|
-
export
|
|
28334
|
-
|
|
28474
|
+
export type FluxTapclicksArchive = typeof fluxTapclicksArchive.$inferSelect;
|
|
28475
|
+
export type NewFluxTapclicksArchive = typeof fluxTapclicksArchive.$inferInsert;
|
|
28476
|
+
export declare const fluxCreativeDeliveryCorrelation: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
28477
|
+
name: "flux_creative_delivery_correlation";
|
|
28335
28478
|
schema: undefined;
|
|
28336
28479
|
columns: {
|
|
28337
28480
|
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
28338
28481
|
name: "id";
|
|
28339
|
-
tableName: "
|
|
28482
|
+
tableName: "flux_creative_delivery_correlation";
|
|
28340
28483
|
dataType: "number";
|
|
28341
28484
|
columnType: "PgSerial";
|
|
28342
28485
|
data: number;
|
|
@@ -28351,9 +28494,9 @@ export declare const fluxComplianceAudit: import("drizzle-orm/pg-core").PgTableW
|
|
|
28351
28494
|
identity: undefined;
|
|
28352
28495
|
generated: undefined;
|
|
28353
28496
|
}, {}, {}>;
|
|
28354
|
-
|
|
28355
|
-
name: "
|
|
28356
|
-
tableName: "
|
|
28497
|
+
correlationType: import("drizzle-orm/pg-core").PgColumn<{
|
|
28498
|
+
name: "correlation_type";
|
|
28499
|
+
tableName: "flux_creative_delivery_correlation";
|
|
28357
28500
|
dataType: "string";
|
|
28358
28501
|
columnType: "PgText";
|
|
28359
28502
|
data: string;
|
|
@@ -28368,14 +28511,14 @@ export declare const fluxComplianceAudit: import("drizzle-orm/pg-core").PgTableW
|
|
|
28368
28511
|
identity: undefined;
|
|
28369
28512
|
generated: undefined;
|
|
28370
28513
|
}, {}, {}>;
|
|
28371
|
-
|
|
28372
|
-
name: "
|
|
28373
|
-
tableName: "
|
|
28514
|
+
segmentKey: import("drizzle-orm/pg-core").PgColumn<{
|
|
28515
|
+
name: "segment_key";
|
|
28516
|
+
tableName: "flux_creative_delivery_correlation";
|
|
28374
28517
|
dataType: "string";
|
|
28375
28518
|
columnType: "PgText";
|
|
28376
28519
|
data: string;
|
|
28377
28520
|
driverParam: string;
|
|
28378
|
-
notNull:
|
|
28521
|
+
notNull: true;
|
|
28379
28522
|
hasDefault: false;
|
|
28380
28523
|
isPrimaryKey: false;
|
|
28381
28524
|
isAutoincrement: false;
|
|
@@ -28385,28 +28528,28 @@ export declare const fluxComplianceAudit: import("drizzle-orm/pg-core").PgTableW
|
|
|
28385
28528
|
identity: undefined;
|
|
28386
28529
|
generated: undefined;
|
|
28387
28530
|
}, {}, {}>;
|
|
28388
|
-
|
|
28389
|
-
name: "
|
|
28390
|
-
tableName: "
|
|
28391
|
-
dataType: "
|
|
28392
|
-
columnType: "
|
|
28393
|
-
data:
|
|
28394
|
-
driverParam: string;
|
|
28395
|
-
notNull:
|
|
28531
|
+
sampleSize: import("drizzle-orm/pg-core").PgColumn<{
|
|
28532
|
+
name: "sample_size";
|
|
28533
|
+
tableName: "flux_creative_delivery_correlation";
|
|
28534
|
+
dataType: "number";
|
|
28535
|
+
columnType: "PgInteger";
|
|
28536
|
+
data: number;
|
|
28537
|
+
driverParam: string | number;
|
|
28538
|
+
notNull: true;
|
|
28396
28539
|
hasDefault: false;
|
|
28397
28540
|
isPrimaryKey: false;
|
|
28398
28541
|
isAutoincrement: false;
|
|
28399
28542
|
hasRuntimeDefault: false;
|
|
28400
|
-
enumValues:
|
|
28543
|
+
enumValues: undefined;
|
|
28401
28544
|
baseColumn: never;
|
|
28402
28545
|
identity: undefined;
|
|
28403
28546
|
generated: undefined;
|
|
28404
28547
|
}, {}, {}>;
|
|
28405
|
-
|
|
28406
|
-
name: "
|
|
28407
|
-
tableName: "
|
|
28548
|
+
avgFillRate: import("drizzle-orm/pg-core").PgColumn<{
|
|
28549
|
+
name: "avg_fill_rate";
|
|
28550
|
+
tableName: "flux_creative_delivery_correlation";
|
|
28408
28551
|
dataType: "string";
|
|
28409
|
-
columnType: "
|
|
28552
|
+
columnType: "PgNumeric";
|
|
28410
28553
|
data: string;
|
|
28411
28554
|
driverParam: string;
|
|
28412
28555
|
notNull: false;
|
|
@@ -28414,16 +28557,16 @@ export declare const fluxComplianceAudit: import("drizzle-orm/pg-core").PgTableW
|
|
|
28414
28557
|
isPrimaryKey: false;
|
|
28415
28558
|
isAutoincrement: false;
|
|
28416
28559
|
hasRuntimeDefault: false;
|
|
28417
|
-
enumValues:
|
|
28560
|
+
enumValues: undefined;
|
|
28418
28561
|
baseColumn: never;
|
|
28419
28562
|
identity: undefined;
|
|
28420
28563
|
generated: undefined;
|
|
28421
28564
|
}, {}, {}>;
|
|
28422
|
-
|
|
28423
|
-
name: "
|
|
28424
|
-
tableName: "
|
|
28565
|
+
avgReadinessScore: import("drizzle-orm/pg-core").PgColumn<{
|
|
28566
|
+
name: "avg_readiness_score";
|
|
28567
|
+
tableName: "flux_creative_delivery_correlation";
|
|
28425
28568
|
dataType: "string";
|
|
28426
|
-
columnType: "
|
|
28569
|
+
columnType: "PgNumeric";
|
|
28427
28570
|
data: string;
|
|
28428
28571
|
driverParam: string;
|
|
28429
28572
|
notNull: false;
|
|
@@ -28431,24 +28574,202 @@ export declare const fluxComplianceAudit: import("drizzle-orm/pg-core").PgTableW
|
|
|
28431
28574
|
isPrimaryKey: false;
|
|
28432
28575
|
isAutoincrement: false;
|
|
28433
28576
|
hasRuntimeDefault: false;
|
|
28434
|
-
enumValues:
|
|
28577
|
+
enumValues: undefined;
|
|
28435
28578
|
baseColumn: never;
|
|
28436
28579
|
identity: undefined;
|
|
28437
28580
|
generated: undefined;
|
|
28438
28581
|
}, {}, {}>;
|
|
28439
|
-
|
|
28440
|
-
name: "
|
|
28441
|
-
tableName: "
|
|
28582
|
+
correlation: import("drizzle-orm/pg-core").PgColumn<{
|
|
28583
|
+
name: "correlation";
|
|
28584
|
+
tableName: "flux_creative_delivery_correlation";
|
|
28442
28585
|
dataType: "string";
|
|
28443
|
-
columnType: "
|
|
28586
|
+
columnType: "PgNumeric";
|
|
28444
28587
|
data: string;
|
|
28445
28588
|
driverParam: string;
|
|
28446
|
-
notNull:
|
|
28589
|
+
notNull: false;
|
|
28447
28590
|
hasDefault: false;
|
|
28448
28591
|
isPrimaryKey: false;
|
|
28449
28592
|
isAutoincrement: false;
|
|
28450
28593
|
hasRuntimeDefault: false;
|
|
28451
|
-
enumValues:
|
|
28594
|
+
enumValues: undefined;
|
|
28595
|
+
baseColumn: never;
|
|
28596
|
+
identity: undefined;
|
|
28597
|
+
generated: undefined;
|
|
28598
|
+
}, {}, {}>;
|
|
28599
|
+
insight: import("drizzle-orm/pg-core").PgColumn<{
|
|
28600
|
+
name: "insight";
|
|
28601
|
+
tableName: "flux_creative_delivery_correlation";
|
|
28602
|
+
dataType: "string";
|
|
28603
|
+
columnType: "PgText";
|
|
28604
|
+
data: string;
|
|
28605
|
+
driverParam: string;
|
|
28606
|
+
notNull: false;
|
|
28607
|
+
hasDefault: false;
|
|
28608
|
+
isPrimaryKey: false;
|
|
28609
|
+
isAutoincrement: false;
|
|
28610
|
+
hasRuntimeDefault: false;
|
|
28611
|
+
enumValues: [string, ...string[]];
|
|
28612
|
+
baseColumn: never;
|
|
28613
|
+
identity: undefined;
|
|
28614
|
+
generated: undefined;
|
|
28615
|
+
}, {}, {}>;
|
|
28616
|
+
metadata: import("drizzle-orm/pg-core").PgColumn<{
|
|
28617
|
+
name: "metadata";
|
|
28618
|
+
tableName: "flux_creative_delivery_correlation";
|
|
28619
|
+
dataType: "json";
|
|
28620
|
+
columnType: "PgJsonb";
|
|
28621
|
+
data: unknown;
|
|
28622
|
+
driverParam: unknown;
|
|
28623
|
+
notNull: false;
|
|
28624
|
+
hasDefault: false;
|
|
28625
|
+
isPrimaryKey: false;
|
|
28626
|
+
isAutoincrement: false;
|
|
28627
|
+
hasRuntimeDefault: false;
|
|
28628
|
+
enumValues: undefined;
|
|
28629
|
+
baseColumn: never;
|
|
28630
|
+
identity: undefined;
|
|
28631
|
+
generated: undefined;
|
|
28632
|
+
}, {}, {}>;
|
|
28633
|
+
computedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
28634
|
+
name: "computed_at";
|
|
28635
|
+
tableName: "flux_creative_delivery_correlation";
|
|
28636
|
+
dataType: "date";
|
|
28637
|
+
columnType: "PgTimestamp";
|
|
28638
|
+
data: Date;
|
|
28639
|
+
driverParam: string;
|
|
28640
|
+
notNull: true;
|
|
28641
|
+
hasDefault: true;
|
|
28642
|
+
isPrimaryKey: false;
|
|
28643
|
+
isAutoincrement: false;
|
|
28644
|
+
hasRuntimeDefault: false;
|
|
28645
|
+
enumValues: undefined;
|
|
28646
|
+
baseColumn: never;
|
|
28647
|
+
identity: undefined;
|
|
28648
|
+
generated: undefined;
|
|
28649
|
+
}, {}, {}>;
|
|
28650
|
+
};
|
|
28651
|
+
dialect: "pg";
|
|
28652
|
+
}>;
|
|
28653
|
+
export type FluxCreativeDeliveryCorrelation = typeof fluxCreativeDeliveryCorrelation.$inferSelect;
|
|
28654
|
+
export declare const fluxComplianceAudit: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
28655
|
+
name: "flux_compliance_audit";
|
|
28656
|
+
schema: undefined;
|
|
28657
|
+
columns: {
|
|
28658
|
+
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
28659
|
+
name: "id";
|
|
28660
|
+
tableName: "flux_compliance_audit";
|
|
28661
|
+
dataType: "number";
|
|
28662
|
+
columnType: "PgSerial";
|
|
28663
|
+
data: number;
|
|
28664
|
+
driverParam: number;
|
|
28665
|
+
notNull: true;
|
|
28666
|
+
hasDefault: true;
|
|
28667
|
+
isPrimaryKey: true;
|
|
28668
|
+
isAutoincrement: false;
|
|
28669
|
+
hasRuntimeDefault: false;
|
|
28670
|
+
enumValues: undefined;
|
|
28671
|
+
baseColumn: never;
|
|
28672
|
+
identity: undefined;
|
|
28673
|
+
generated: undefined;
|
|
28674
|
+
}, {}, {}>;
|
|
28675
|
+
lineItemId: import("drizzle-orm/pg-core").PgColumn<{
|
|
28676
|
+
name: "line_item_id";
|
|
28677
|
+
tableName: "flux_compliance_audit";
|
|
28678
|
+
dataType: "string";
|
|
28679
|
+
columnType: "PgText";
|
|
28680
|
+
data: string;
|
|
28681
|
+
driverParam: string;
|
|
28682
|
+
notNull: true;
|
|
28683
|
+
hasDefault: false;
|
|
28684
|
+
isPrimaryKey: false;
|
|
28685
|
+
isAutoincrement: false;
|
|
28686
|
+
hasRuntimeDefault: false;
|
|
28687
|
+
enumValues: [string, ...string[]];
|
|
28688
|
+
baseColumn: never;
|
|
28689
|
+
identity: undefined;
|
|
28690
|
+
generated: undefined;
|
|
28691
|
+
}, {}, {}>;
|
|
28692
|
+
lineItemName: import("drizzle-orm/pg-core").PgColumn<{
|
|
28693
|
+
name: "line_item_name";
|
|
28694
|
+
tableName: "flux_compliance_audit";
|
|
28695
|
+
dataType: "string";
|
|
28696
|
+
columnType: "PgText";
|
|
28697
|
+
data: string;
|
|
28698
|
+
driverParam: string;
|
|
28699
|
+
notNull: false;
|
|
28700
|
+
hasDefault: false;
|
|
28701
|
+
isPrimaryKey: false;
|
|
28702
|
+
isAutoincrement: false;
|
|
28703
|
+
hasRuntimeDefault: false;
|
|
28704
|
+
enumValues: [string, ...string[]];
|
|
28705
|
+
baseColumn: never;
|
|
28706
|
+
identity: undefined;
|
|
28707
|
+
generated: undefined;
|
|
28708
|
+
}, {}, {}>;
|
|
28709
|
+
orderId: import("drizzle-orm/pg-core").PgColumn<{
|
|
28710
|
+
name: "order_id";
|
|
28711
|
+
tableName: "flux_compliance_audit";
|
|
28712
|
+
dataType: "string";
|
|
28713
|
+
columnType: "PgText";
|
|
28714
|
+
data: string;
|
|
28715
|
+
driverParam: string;
|
|
28716
|
+
notNull: false;
|
|
28717
|
+
hasDefault: false;
|
|
28718
|
+
isPrimaryKey: false;
|
|
28719
|
+
isAutoincrement: false;
|
|
28720
|
+
hasRuntimeDefault: false;
|
|
28721
|
+
enumValues: [string, ...string[]];
|
|
28722
|
+
baseColumn: never;
|
|
28723
|
+
identity: undefined;
|
|
28724
|
+
generated: undefined;
|
|
28725
|
+
}, {}, {}>;
|
|
28726
|
+
orderName: import("drizzle-orm/pg-core").PgColumn<{
|
|
28727
|
+
name: "order_name";
|
|
28728
|
+
tableName: "flux_compliance_audit";
|
|
28729
|
+
dataType: "string";
|
|
28730
|
+
columnType: "PgText";
|
|
28731
|
+
data: string;
|
|
28732
|
+
driverParam: string;
|
|
28733
|
+
notNull: false;
|
|
28734
|
+
hasDefault: false;
|
|
28735
|
+
isPrimaryKey: false;
|
|
28736
|
+
isAutoincrement: false;
|
|
28737
|
+
hasRuntimeDefault: false;
|
|
28738
|
+
enumValues: [string, ...string[]];
|
|
28739
|
+
baseColumn: never;
|
|
28740
|
+
identity: undefined;
|
|
28741
|
+
generated: undefined;
|
|
28742
|
+
}, {}, {}>;
|
|
28743
|
+
lineItemStatus: import("drizzle-orm/pg-core").PgColumn<{
|
|
28744
|
+
name: "line_item_status";
|
|
28745
|
+
tableName: "flux_compliance_audit";
|
|
28746
|
+
dataType: "string";
|
|
28747
|
+
columnType: "PgText";
|
|
28748
|
+
data: string;
|
|
28749
|
+
driverParam: string;
|
|
28750
|
+
notNull: false;
|
|
28751
|
+
hasDefault: false;
|
|
28752
|
+
isPrimaryKey: false;
|
|
28753
|
+
isAutoincrement: false;
|
|
28754
|
+
hasRuntimeDefault: false;
|
|
28755
|
+
enumValues: [string, ...string[]];
|
|
28756
|
+
baseColumn: never;
|
|
28757
|
+
identity: undefined;
|
|
28758
|
+
generated: undefined;
|
|
28759
|
+
}, {}, {}>;
|
|
28760
|
+
audienceSegmentId: import("drizzle-orm/pg-core").PgColumn<{
|
|
28761
|
+
name: "audience_segment_id";
|
|
28762
|
+
tableName: "flux_compliance_audit";
|
|
28763
|
+
dataType: "string";
|
|
28764
|
+
columnType: "PgText";
|
|
28765
|
+
data: string;
|
|
28766
|
+
driverParam: string;
|
|
28767
|
+
notNull: true;
|
|
28768
|
+
hasDefault: false;
|
|
28769
|
+
isPrimaryKey: false;
|
|
28770
|
+
isAutoincrement: false;
|
|
28771
|
+
hasRuntimeDefault: false;
|
|
28772
|
+
enumValues: [string, ...string[]];
|
|
28452
28773
|
baseColumn: never;
|
|
28453
28774
|
identity: undefined;
|
|
28454
28775
|
generated: undefined;
|
|
@@ -35561,6 +35882,23 @@ export declare const fluxSemPreresearchRuns: import("drizzle-orm/pg-core").PgTab
|
|
|
35561
35882
|
identity: undefined;
|
|
35562
35883
|
generated: undefined;
|
|
35563
35884
|
}, {}, {}>;
|
|
35885
|
+
updatedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
35886
|
+
name: "updated_at";
|
|
35887
|
+
tableName: "flux_sem_preresearch_runs";
|
|
35888
|
+
dataType: "date";
|
|
35889
|
+
columnType: "PgTimestamp";
|
|
35890
|
+
data: Date;
|
|
35891
|
+
driverParam: string;
|
|
35892
|
+
notNull: true;
|
|
35893
|
+
hasDefault: true;
|
|
35894
|
+
isPrimaryKey: false;
|
|
35895
|
+
isAutoincrement: false;
|
|
35896
|
+
hasRuntimeDefault: false;
|
|
35897
|
+
enumValues: undefined;
|
|
35898
|
+
baseColumn: never;
|
|
35899
|
+
identity: undefined;
|
|
35900
|
+
generated: undefined;
|
|
35901
|
+
}, {}, {}>;
|
|
35564
35902
|
};
|
|
35565
35903
|
dialect: "pg";
|
|
35566
35904
|
}>;
|
|
@@ -39932,66 +40270,535 @@ export declare const fluxOnboardingResponses: import("drizzle-orm/pg-core").PgTa
|
|
|
39932
40270
|
isPrimaryKey: false;
|
|
39933
40271
|
isAutoincrement: false;
|
|
39934
40272
|
hasRuntimeDefault: false;
|
|
39935
|
-
enumValues: undefined;
|
|
40273
|
+
enumValues: undefined;
|
|
40274
|
+
baseColumn: never;
|
|
40275
|
+
identity: undefined;
|
|
40276
|
+
generated: undefined;
|
|
40277
|
+
}, {}, {}>;
|
|
40278
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
40279
|
+
name: "created_at";
|
|
40280
|
+
tableName: "flux_onboarding_responses";
|
|
40281
|
+
dataType: "date";
|
|
40282
|
+
columnType: "PgTimestamp";
|
|
40283
|
+
data: Date;
|
|
40284
|
+
driverParam: string;
|
|
40285
|
+
notNull: true;
|
|
40286
|
+
hasDefault: true;
|
|
40287
|
+
isPrimaryKey: false;
|
|
40288
|
+
isAutoincrement: false;
|
|
40289
|
+
hasRuntimeDefault: false;
|
|
40290
|
+
enumValues: undefined;
|
|
40291
|
+
baseColumn: never;
|
|
40292
|
+
identity: undefined;
|
|
40293
|
+
generated: undefined;
|
|
40294
|
+
}, {}, {}>;
|
|
40295
|
+
updatedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
40296
|
+
name: "updated_at";
|
|
40297
|
+
tableName: "flux_onboarding_responses";
|
|
40298
|
+
dataType: "date";
|
|
40299
|
+
columnType: "PgTimestamp";
|
|
40300
|
+
data: Date;
|
|
40301
|
+
driverParam: string;
|
|
40302
|
+
notNull: true;
|
|
40303
|
+
hasDefault: true;
|
|
40304
|
+
isPrimaryKey: false;
|
|
40305
|
+
isAutoincrement: false;
|
|
40306
|
+
hasRuntimeDefault: false;
|
|
40307
|
+
enumValues: undefined;
|
|
40308
|
+
baseColumn: never;
|
|
40309
|
+
identity: undefined;
|
|
40310
|
+
generated: undefined;
|
|
40311
|
+
}, {}, {}>;
|
|
40312
|
+
};
|
|
40313
|
+
dialect: "pg";
|
|
40314
|
+
}>;
|
|
40315
|
+
/**
|
|
40316
|
+
* File uploads during onboarding — logos, brand guides, creative assets.
|
|
40317
|
+
* Stored in Cloudflare R2 with prefix `flux-onboarding/`.
|
|
40318
|
+
*/
|
|
40319
|
+
export declare const fluxOnboardingFiles: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
40320
|
+
name: "flux_onboarding_files";
|
|
40321
|
+
schema: undefined;
|
|
40322
|
+
columns: {
|
|
40323
|
+
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
40324
|
+
name: "id";
|
|
40325
|
+
tableName: "flux_onboarding_files";
|
|
40326
|
+
dataType: "string";
|
|
40327
|
+
columnType: "PgText";
|
|
40328
|
+
data: string;
|
|
40329
|
+
driverParam: string;
|
|
40330
|
+
notNull: true;
|
|
40331
|
+
hasDefault: true;
|
|
40332
|
+
isPrimaryKey: true;
|
|
40333
|
+
isAutoincrement: false;
|
|
40334
|
+
hasRuntimeDefault: false;
|
|
40335
|
+
enumValues: [string, ...string[]];
|
|
40336
|
+
baseColumn: never;
|
|
40337
|
+
identity: undefined;
|
|
40338
|
+
generated: undefined;
|
|
40339
|
+
}, {}, {}>;
|
|
40340
|
+
onboardingId: import("drizzle-orm/pg-core").PgColumn<{
|
|
40341
|
+
name: "onboarding_id";
|
|
40342
|
+
tableName: "flux_onboarding_files";
|
|
40343
|
+
dataType: "string";
|
|
40344
|
+
columnType: "PgText";
|
|
40345
|
+
data: string;
|
|
40346
|
+
driverParam: string;
|
|
40347
|
+
notNull: true;
|
|
40348
|
+
hasDefault: false;
|
|
40349
|
+
isPrimaryKey: false;
|
|
40350
|
+
isAutoincrement: false;
|
|
40351
|
+
hasRuntimeDefault: false;
|
|
40352
|
+
enumValues: [string, ...string[]];
|
|
40353
|
+
baseColumn: never;
|
|
40354
|
+
identity: undefined;
|
|
40355
|
+
generated: undefined;
|
|
40356
|
+
}, {}, {}>;
|
|
40357
|
+
sectionId: import("drizzle-orm/pg-core").PgColumn<{
|
|
40358
|
+
name: "section_id";
|
|
40359
|
+
tableName: "flux_onboarding_files";
|
|
40360
|
+
dataType: "string";
|
|
40361
|
+
columnType: "PgText";
|
|
40362
|
+
data: string;
|
|
40363
|
+
driverParam: string;
|
|
40364
|
+
notNull: false;
|
|
40365
|
+
hasDefault: false;
|
|
40366
|
+
isPrimaryKey: false;
|
|
40367
|
+
isAutoincrement: false;
|
|
40368
|
+
hasRuntimeDefault: false;
|
|
40369
|
+
enumValues: [string, ...string[]];
|
|
40370
|
+
baseColumn: never;
|
|
40371
|
+
identity: undefined;
|
|
40372
|
+
generated: undefined;
|
|
40373
|
+
}, {}, {}>;
|
|
40374
|
+
responseId: import("drizzle-orm/pg-core").PgColumn<{
|
|
40375
|
+
name: "response_id";
|
|
40376
|
+
tableName: "flux_onboarding_files";
|
|
40377
|
+
dataType: "string";
|
|
40378
|
+
columnType: "PgText";
|
|
40379
|
+
data: string;
|
|
40380
|
+
driverParam: string;
|
|
40381
|
+
notNull: false;
|
|
40382
|
+
hasDefault: false;
|
|
40383
|
+
isPrimaryKey: false;
|
|
40384
|
+
isAutoincrement: false;
|
|
40385
|
+
hasRuntimeDefault: false;
|
|
40386
|
+
enumValues: [string, ...string[]];
|
|
40387
|
+
baseColumn: never;
|
|
40388
|
+
identity: undefined;
|
|
40389
|
+
generated: undefined;
|
|
40390
|
+
}, {}, {}>;
|
|
40391
|
+
fileName: import("drizzle-orm/pg-core").PgColumn<{
|
|
40392
|
+
name: "file_name";
|
|
40393
|
+
tableName: "flux_onboarding_files";
|
|
40394
|
+
dataType: "string";
|
|
40395
|
+
columnType: "PgText";
|
|
40396
|
+
data: string;
|
|
40397
|
+
driverParam: string;
|
|
40398
|
+
notNull: true;
|
|
40399
|
+
hasDefault: false;
|
|
40400
|
+
isPrimaryKey: false;
|
|
40401
|
+
isAutoincrement: false;
|
|
40402
|
+
hasRuntimeDefault: false;
|
|
40403
|
+
enumValues: [string, ...string[]];
|
|
40404
|
+
baseColumn: never;
|
|
40405
|
+
identity: undefined;
|
|
40406
|
+
generated: undefined;
|
|
40407
|
+
}, {}, {}>;
|
|
40408
|
+
fileType: import("drizzle-orm/pg-core").PgColumn<{
|
|
40409
|
+
name: "file_type";
|
|
40410
|
+
tableName: "flux_onboarding_files";
|
|
40411
|
+
dataType: "string";
|
|
40412
|
+
columnType: "PgText";
|
|
40413
|
+
data: string;
|
|
40414
|
+
driverParam: string;
|
|
40415
|
+
notNull: true;
|
|
40416
|
+
hasDefault: false;
|
|
40417
|
+
isPrimaryKey: false;
|
|
40418
|
+
isAutoincrement: false;
|
|
40419
|
+
hasRuntimeDefault: false;
|
|
40420
|
+
enumValues: [string, ...string[]];
|
|
40421
|
+
baseColumn: never;
|
|
40422
|
+
identity: undefined;
|
|
40423
|
+
generated: undefined;
|
|
40424
|
+
}, {}, {}>;
|
|
40425
|
+
fileSizeBytes: import("drizzle-orm/pg-core").PgColumn<{
|
|
40426
|
+
name: "file_size_bytes";
|
|
40427
|
+
tableName: "flux_onboarding_files";
|
|
40428
|
+
dataType: "number";
|
|
40429
|
+
columnType: "PgInteger";
|
|
40430
|
+
data: number;
|
|
40431
|
+
driverParam: string | number;
|
|
40432
|
+
notNull: true;
|
|
40433
|
+
hasDefault: false;
|
|
40434
|
+
isPrimaryKey: false;
|
|
40435
|
+
isAutoincrement: false;
|
|
40436
|
+
hasRuntimeDefault: false;
|
|
40437
|
+
enumValues: undefined;
|
|
40438
|
+
baseColumn: never;
|
|
40439
|
+
identity: undefined;
|
|
40440
|
+
generated: undefined;
|
|
40441
|
+
}, {}, {}>;
|
|
40442
|
+
r2Key: import("drizzle-orm/pg-core").PgColumn<{
|
|
40443
|
+
name: "r2_key";
|
|
40444
|
+
tableName: "flux_onboarding_files";
|
|
40445
|
+
dataType: "string";
|
|
40446
|
+
columnType: "PgText";
|
|
40447
|
+
data: string;
|
|
40448
|
+
driverParam: string;
|
|
40449
|
+
notNull: true;
|
|
40450
|
+
hasDefault: false;
|
|
40451
|
+
isPrimaryKey: false;
|
|
40452
|
+
isAutoincrement: false;
|
|
40453
|
+
hasRuntimeDefault: false;
|
|
40454
|
+
enumValues: [string, ...string[]];
|
|
40455
|
+
baseColumn: never;
|
|
40456
|
+
identity: undefined;
|
|
40457
|
+
generated: undefined;
|
|
40458
|
+
}, {}, {}>;
|
|
40459
|
+
r2Bucket: import("drizzle-orm/pg-core").PgColumn<{
|
|
40460
|
+
name: "r2_bucket";
|
|
40461
|
+
tableName: "flux_onboarding_files";
|
|
40462
|
+
dataType: "string";
|
|
40463
|
+
columnType: "PgText";
|
|
40464
|
+
data: string;
|
|
40465
|
+
driverParam: string;
|
|
40466
|
+
notNull: true;
|
|
40467
|
+
hasDefault: false;
|
|
40468
|
+
isPrimaryKey: false;
|
|
40469
|
+
isAutoincrement: false;
|
|
40470
|
+
hasRuntimeDefault: false;
|
|
40471
|
+
enumValues: [string, ...string[]];
|
|
40472
|
+
baseColumn: never;
|
|
40473
|
+
identity: undefined;
|
|
40474
|
+
generated: undefined;
|
|
40475
|
+
}, {}, {}>;
|
|
40476
|
+
category: import("drizzle-orm/pg-core").PgColumn<{
|
|
40477
|
+
name: "category";
|
|
40478
|
+
tableName: "flux_onboarding_files";
|
|
40479
|
+
dataType: "string";
|
|
40480
|
+
columnType: "PgEnumColumn";
|
|
40481
|
+
data: "other" | "logo" | "brand_guide" | "creative_asset" | "tracking_doc";
|
|
40482
|
+
driverParam: string;
|
|
40483
|
+
notNull: true;
|
|
40484
|
+
hasDefault: true;
|
|
40485
|
+
isPrimaryKey: false;
|
|
40486
|
+
isAutoincrement: false;
|
|
40487
|
+
hasRuntimeDefault: false;
|
|
40488
|
+
enumValues: ["logo", "brand_guide", "creative_asset", "tracking_doc", "other"];
|
|
40489
|
+
baseColumn: never;
|
|
40490
|
+
identity: undefined;
|
|
40491
|
+
generated: undefined;
|
|
40492
|
+
}, {}, {}>;
|
|
40493
|
+
uploadedBy: import("drizzle-orm/pg-core").PgColumn<{
|
|
40494
|
+
name: "uploaded_by";
|
|
40495
|
+
tableName: "flux_onboarding_files";
|
|
40496
|
+
dataType: "string";
|
|
40497
|
+
columnType: "PgText";
|
|
40498
|
+
data: string;
|
|
40499
|
+
driverParam: string;
|
|
40500
|
+
notNull: false;
|
|
40501
|
+
hasDefault: false;
|
|
40502
|
+
isPrimaryKey: false;
|
|
40503
|
+
isAutoincrement: false;
|
|
40504
|
+
hasRuntimeDefault: false;
|
|
40505
|
+
enumValues: [string, ...string[]];
|
|
40506
|
+
baseColumn: never;
|
|
40507
|
+
identity: undefined;
|
|
40508
|
+
generated: undefined;
|
|
40509
|
+
}, {}, {}>;
|
|
40510
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
40511
|
+
name: "created_at";
|
|
40512
|
+
tableName: "flux_onboarding_files";
|
|
40513
|
+
dataType: "date";
|
|
40514
|
+
columnType: "PgTimestamp";
|
|
40515
|
+
data: Date;
|
|
40516
|
+
driverParam: string;
|
|
40517
|
+
notNull: true;
|
|
40518
|
+
hasDefault: true;
|
|
40519
|
+
isPrimaryKey: false;
|
|
40520
|
+
isAutoincrement: false;
|
|
40521
|
+
hasRuntimeDefault: false;
|
|
40522
|
+
enumValues: undefined;
|
|
40523
|
+
baseColumn: never;
|
|
40524
|
+
identity: undefined;
|
|
40525
|
+
generated: undefined;
|
|
40526
|
+
}, {}, {}>;
|
|
40527
|
+
};
|
|
40528
|
+
dialect: "pg";
|
|
40529
|
+
}>;
|
|
40530
|
+
/**
|
|
40531
|
+
* Audit trail for all onboarding events — who did what, when.
|
|
40532
|
+
* Tracks both client and internal team actions.
|
|
40533
|
+
*/
|
|
40534
|
+
export declare const fluxOnboardingActivity: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
40535
|
+
name: "flux_onboarding_activity";
|
|
40536
|
+
schema: undefined;
|
|
40537
|
+
columns: {
|
|
40538
|
+
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
40539
|
+
name: "id";
|
|
40540
|
+
tableName: "flux_onboarding_activity";
|
|
40541
|
+
dataType: "string";
|
|
40542
|
+
columnType: "PgText";
|
|
40543
|
+
data: string;
|
|
40544
|
+
driverParam: string;
|
|
40545
|
+
notNull: true;
|
|
40546
|
+
hasDefault: true;
|
|
40547
|
+
isPrimaryKey: true;
|
|
40548
|
+
isAutoincrement: false;
|
|
40549
|
+
hasRuntimeDefault: false;
|
|
40550
|
+
enumValues: [string, ...string[]];
|
|
40551
|
+
baseColumn: never;
|
|
40552
|
+
identity: undefined;
|
|
40553
|
+
generated: undefined;
|
|
40554
|
+
}, {}, {}>;
|
|
40555
|
+
onboardingId: import("drizzle-orm/pg-core").PgColumn<{
|
|
40556
|
+
name: "onboarding_id";
|
|
40557
|
+
tableName: "flux_onboarding_activity";
|
|
40558
|
+
dataType: "string";
|
|
40559
|
+
columnType: "PgText";
|
|
40560
|
+
data: string;
|
|
40561
|
+
driverParam: string;
|
|
40562
|
+
notNull: true;
|
|
40563
|
+
hasDefault: false;
|
|
40564
|
+
isPrimaryKey: false;
|
|
40565
|
+
isAutoincrement: false;
|
|
40566
|
+
hasRuntimeDefault: false;
|
|
40567
|
+
enumValues: [string, ...string[]];
|
|
40568
|
+
baseColumn: never;
|
|
40569
|
+
identity: undefined;
|
|
40570
|
+
generated: undefined;
|
|
40571
|
+
}, {}, {}>;
|
|
40572
|
+
actor: import("drizzle-orm/pg-core").PgColumn<{
|
|
40573
|
+
name: "actor";
|
|
40574
|
+
tableName: "flux_onboarding_activity";
|
|
40575
|
+
dataType: "string";
|
|
40576
|
+
columnType: "PgText";
|
|
40577
|
+
data: string;
|
|
40578
|
+
driverParam: string;
|
|
40579
|
+
notNull: true;
|
|
40580
|
+
hasDefault: false;
|
|
40581
|
+
isPrimaryKey: false;
|
|
40582
|
+
isAutoincrement: false;
|
|
40583
|
+
hasRuntimeDefault: false;
|
|
40584
|
+
enumValues: [string, ...string[]];
|
|
40585
|
+
baseColumn: never;
|
|
40586
|
+
identity: undefined;
|
|
40587
|
+
generated: undefined;
|
|
40588
|
+
}, {}, {}>;
|
|
40589
|
+
actorType: import("drizzle-orm/pg-core").PgColumn<{
|
|
40590
|
+
name: "actor_type";
|
|
40591
|
+
tableName: "flux_onboarding_activity";
|
|
40592
|
+
dataType: "string";
|
|
40593
|
+
columnType: "PgText";
|
|
40594
|
+
data: string;
|
|
40595
|
+
driverParam: string;
|
|
40596
|
+
notNull: true;
|
|
40597
|
+
hasDefault: false;
|
|
40598
|
+
isPrimaryKey: false;
|
|
40599
|
+
isAutoincrement: false;
|
|
40600
|
+
hasRuntimeDefault: false;
|
|
40601
|
+
enumValues: [string, ...string[]];
|
|
40602
|
+
baseColumn: never;
|
|
40603
|
+
identity: undefined;
|
|
40604
|
+
generated: undefined;
|
|
40605
|
+
}, {}, {}>;
|
|
40606
|
+
action: import("drizzle-orm/pg-core").PgColumn<{
|
|
40607
|
+
name: "action";
|
|
40608
|
+
tableName: "flux_onboarding_activity";
|
|
40609
|
+
dataType: "string";
|
|
40610
|
+
columnType: "PgEnumColumn";
|
|
40611
|
+
data: "created" | "completed" | "approved" | "magic_link_sent" | "client_opened" | "section_started" | "section_submitted" | "section_approved" | "section_revision_requested" | "file_uploaded" | "reminder_sent" | "reopened" | "stale_detected" | "ae_context_saved" | "ready_for_client" | "contract_acknowledged";
|
|
40612
|
+
driverParam: string;
|
|
40613
|
+
notNull: true;
|
|
40614
|
+
hasDefault: false;
|
|
40615
|
+
isPrimaryKey: false;
|
|
40616
|
+
isAutoincrement: false;
|
|
40617
|
+
hasRuntimeDefault: false;
|
|
40618
|
+
enumValues: ["created", "magic_link_sent", "client_opened", "section_started", "section_submitted", "section_approved", "section_revision_requested", "file_uploaded", "reminder_sent", "approved", "completed", "reopened", "stale_detected", "ae_context_saved", "ready_for_client", "contract_acknowledged"];
|
|
40619
|
+
baseColumn: never;
|
|
40620
|
+
identity: undefined;
|
|
40621
|
+
generated: undefined;
|
|
40622
|
+
}, {}, {}>;
|
|
40623
|
+
metadata: import("drizzle-orm/pg-core").PgColumn<{
|
|
40624
|
+
name: "metadata";
|
|
40625
|
+
tableName: "flux_onboarding_activity";
|
|
40626
|
+
dataType: "json";
|
|
40627
|
+
columnType: "PgJsonb";
|
|
40628
|
+
data: Record<string, unknown>;
|
|
40629
|
+
driverParam: unknown;
|
|
40630
|
+
notNull: false;
|
|
40631
|
+
hasDefault: true;
|
|
40632
|
+
isPrimaryKey: false;
|
|
40633
|
+
isAutoincrement: false;
|
|
40634
|
+
hasRuntimeDefault: false;
|
|
40635
|
+
enumValues: undefined;
|
|
40636
|
+
baseColumn: never;
|
|
40637
|
+
identity: undefined;
|
|
40638
|
+
generated: undefined;
|
|
40639
|
+
}, {}, {
|
|
40640
|
+
$type: Record<string, unknown>;
|
|
40641
|
+
}>;
|
|
40642
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
40643
|
+
name: "created_at";
|
|
40644
|
+
tableName: "flux_onboarding_activity";
|
|
40645
|
+
dataType: "date";
|
|
40646
|
+
columnType: "PgTimestamp";
|
|
40647
|
+
data: Date;
|
|
40648
|
+
driverParam: string;
|
|
40649
|
+
notNull: true;
|
|
40650
|
+
hasDefault: true;
|
|
40651
|
+
isPrimaryKey: false;
|
|
40652
|
+
isAutoincrement: false;
|
|
40653
|
+
hasRuntimeDefault: false;
|
|
40654
|
+
enumValues: undefined;
|
|
40655
|
+
baseColumn: never;
|
|
40656
|
+
identity: undefined;
|
|
40657
|
+
generated: undefined;
|
|
40658
|
+
}, {}, {}>;
|
|
40659
|
+
};
|
|
40660
|
+
dialect: "pg";
|
|
40661
|
+
}>;
|
|
40662
|
+
export declare const fluxOnboardingsRelations: import("drizzle-orm").Relations<"flux_onboardings", {
|
|
40663
|
+
project: import("drizzle-orm").One<"flux_projects", true>;
|
|
40664
|
+
approvedByUser: import("drizzle-orm").One<"flux_users", false>;
|
|
40665
|
+
createdByUser: import("drizzle-orm").One<"flux_users", false>;
|
|
40666
|
+
renewalParent: import("drizzle-orm").One<"flux_onboardings", false>;
|
|
40667
|
+
renewalChildren: import("drizzle-orm").Many<"flux_onboardings">;
|
|
40668
|
+
sections: import("drizzle-orm").Many<"flux_onboarding_sections">;
|
|
40669
|
+
files: import("drizzle-orm").Many<"flux_onboarding_files">;
|
|
40670
|
+
activity: import("drizzle-orm").Many<"flux_onboarding_activity">;
|
|
40671
|
+
}>;
|
|
40672
|
+
export declare const fluxOnboardingSectionsRelations: import("drizzle-orm").Relations<"flux_onboarding_sections", {
|
|
40673
|
+
onboarding: import("drizzle-orm").One<"flux_onboardings", true>;
|
|
40674
|
+
reviewedByUser: import("drizzle-orm").One<"flux_users", false>;
|
|
40675
|
+
responses: import("drizzle-orm").Many<"flux_onboarding_responses">;
|
|
40676
|
+
files: import("drizzle-orm").Many<"flux_onboarding_files">;
|
|
40677
|
+
}>;
|
|
40678
|
+
export declare const fluxOnboardingResponsesRelations: import("drizzle-orm").Relations<"flux_onboarding_responses", {
|
|
40679
|
+
section: import("drizzle-orm").One<"flux_onboarding_sections", true>;
|
|
40680
|
+
files: import("drizzle-orm").Many<"flux_onboarding_files">;
|
|
40681
|
+
}>;
|
|
40682
|
+
export declare const fluxOnboardingFilesRelations: import("drizzle-orm").Relations<"flux_onboarding_files", {
|
|
40683
|
+
onboarding: import("drizzle-orm").One<"flux_onboardings", true>;
|
|
40684
|
+
section: import("drizzle-orm").One<"flux_onboarding_sections", false>;
|
|
40685
|
+
response: import("drizzle-orm").One<"flux_onboarding_responses", false>;
|
|
40686
|
+
}>;
|
|
40687
|
+
export declare const fluxOnboardingActivityRelations: import("drizzle-orm").Relations<"flux_onboarding_activity", {
|
|
40688
|
+
onboarding: import("drizzle-orm").One<"flux_onboardings", true>;
|
|
40689
|
+
}>;
|
|
40690
|
+
export type FluxOnboarding = typeof fluxOnboardings.$inferSelect;
|
|
40691
|
+
export type NewFluxOnboarding = typeof fluxOnboardings.$inferInsert;
|
|
40692
|
+
export type FluxOnboardingSection = typeof fluxOnboardingSections.$inferSelect;
|
|
40693
|
+
export type NewFluxOnboardingSection = typeof fluxOnboardingSections.$inferInsert;
|
|
40694
|
+
export type FluxOnboardingResponse = typeof fluxOnboardingResponses.$inferSelect;
|
|
40695
|
+
export type NewFluxOnboardingResponse = typeof fluxOnboardingResponses.$inferInsert;
|
|
40696
|
+
export type FluxOnboardingFile = typeof fluxOnboardingFiles.$inferSelect;
|
|
40697
|
+
export type NewFluxOnboardingFile = typeof fluxOnboardingFiles.$inferInsert;
|
|
40698
|
+
export type FluxOnboardingActivityRecord = typeof fluxOnboardingActivity.$inferSelect;
|
|
40699
|
+
export type NewFluxOnboardingActivityRecord = typeof fluxOnboardingActivity.$inferInsert;
|
|
40700
|
+
export declare const fluxClientApprovalRequestStatusEnum: import("drizzle-orm/pg-core").PgEnum<["pending", "approved", "changes_requested", "expired", "canceled"]>;
|
|
40701
|
+
export declare const fluxClientApprovalDisciplineKindEnum: import("drizzle-orm/pg-core").PgEnum<["paid_search", "seo", "geo", "aeo", "reviews"]>;
|
|
40702
|
+
export declare const fluxClientApprovalSubjectTypeEnum: import("drizzle-orm/pg-core").PgEnum<["plan", "change_pack", "deliverable", "keyword_list", "ad_copy"]>;
|
|
40703
|
+
export declare const fluxClientApprovalRequests: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
40704
|
+
name: "flux_client_approval_requests";
|
|
40705
|
+
schema: undefined;
|
|
40706
|
+
columns: {
|
|
40707
|
+
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
40708
|
+
name: "id";
|
|
40709
|
+
tableName: "flux_client_approval_requests";
|
|
40710
|
+
dataType: "string";
|
|
40711
|
+
columnType: "PgText";
|
|
40712
|
+
data: string;
|
|
40713
|
+
driverParam: string;
|
|
40714
|
+
notNull: true;
|
|
40715
|
+
hasDefault: true;
|
|
40716
|
+
isPrimaryKey: true;
|
|
40717
|
+
isAutoincrement: false;
|
|
40718
|
+
hasRuntimeDefault: false;
|
|
40719
|
+
enumValues: [string, ...string[]];
|
|
40720
|
+
baseColumn: never;
|
|
40721
|
+
identity: undefined;
|
|
40722
|
+
generated: undefined;
|
|
40723
|
+
}, {}, {}>;
|
|
40724
|
+
accountId: import("drizzle-orm/pg-core").PgColumn<{
|
|
40725
|
+
name: "account_id";
|
|
40726
|
+
tableName: "flux_client_approval_requests";
|
|
40727
|
+
dataType: "string";
|
|
40728
|
+
columnType: "PgText";
|
|
40729
|
+
data: string;
|
|
40730
|
+
driverParam: string;
|
|
40731
|
+
notNull: true;
|
|
40732
|
+
hasDefault: false;
|
|
40733
|
+
isPrimaryKey: false;
|
|
40734
|
+
isAutoincrement: false;
|
|
40735
|
+
hasRuntimeDefault: false;
|
|
40736
|
+
enumValues: [string, ...string[]];
|
|
40737
|
+
baseColumn: never;
|
|
40738
|
+
identity: undefined;
|
|
40739
|
+
generated: undefined;
|
|
40740
|
+
}, {}, {}>;
|
|
40741
|
+
disciplineKind: import("drizzle-orm/pg-core").PgColumn<{
|
|
40742
|
+
name: "discipline_kind";
|
|
40743
|
+
tableName: "flux_client_approval_requests";
|
|
40744
|
+
dataType: "string";
|
|
40745
|
+
columnType: "PgEnumColumn";
|
|
40746
|
+
data: "geo" | "paid_search" | "seo" | "aeo" | "reviews";
|
|
40747
|
+
driverParam: string;
|
|
40748
|
+
notNull: true;
|
|
40749
|
+
hasDefault: false;
|
|
40750
|
+
isPrimaryKey: false;
|
|
40751
|
+
isAutoincrement: false;
|
|
40752
|
+
hasRuntimeDefault: false;
|
|
40753
|
+
enumValues: ["paid_search", "seo", "geo", "aeo", "reviews"];
|
|
39936
40754
|
baseColumn: never;
|
|
39937
40755
|
identity: undefined;
|
|
39938
40756
|
generated: undefined;
|
|
39939
40757
|
}, {}, {}>;
|
|
39940
|
-
|
|
39941
|
-
name: "
|
|
39942
|
-
tableName: "
|
|
39943
|
-
dataType: "
|
|
39944
|
-
columnType: "
|
|
39945
|
-
data:
|
|
40758
|
+
subjectType: import("drizzle-orm/pg-core").PgColumn<{
|
|
40759
|
+
name: "subject_type";
|
|
40760
|
+
tableName: "flux_client_approval_requests";
|
|
40761
|
+
dataType: "string";
|
|
40762
|
+
columnType: "PgEnumColumn";
|
|
40763
|
+
data: "plan" | "change_pack" | "deliverable" | "keyword_list" | "ad_copy";
|
|
39946
40764
|
driverParam: string;
|
|
39947
40765
|
notNull: true;
|
|
39948
|
-
hasDefault:
|
|
40766
|
+
hasDefault: false;
|
|
39949
40767
|
isPrimaryKey: false;
|
|
39950
40768
|
isAutoincrement: false;
|
|
39951
40769
|
hasRuntimeDefault: false;
|
|
39952
|
-
enumValues:
|
|
40770
|
+
enumValues: ["plan", "change_pack", "deliverable", "keyword_list", "ad_copy"];
|
|
39953
40771
|
baseColumn: never;
|
|
39954
40772
|
identity: undefined;
|
|
39955
40773
|
generated: undefined;
|
|
39956
40774
|
}, {}, {}>;
|
|
39957
|
-
|
|
39958
|
-
name: "
|
|
39959
|
-
tableName: "
|
|
39960
|
-
dataType: "
|
|
39961
|
-
columnType: "
|
|
39962
|
-
data:
|
|
40775
|
+
subjectId: import("drizzle-orm/pg-core").PgColumn<{
|
|
40776
|
+
name: "subject_id";
|
|
40777
|
+
tableName: "flux_client_approval_requests";
|
|
40778
|
+
dataType: "string";
|
|
40779
|
+
columnType: "PgText";
|
|
40780
|
+
data: string;
|
|
39963
40781
|
driverParam: string;
|
|
39964
40782
|
notNull: true;
|
|
39965
|
-
hasDefault:
|
|
40783
|
+
hasDefault: false;
|
|
39966
40784
|
isPrimaryKey: false;
|
|
39967
40785
|
isAutoincrement: false;
|
|
39968
40786
|
hasRuntimeDefault: false;
|
|
39969
|
-
enumValues:
|
|
40787
|
+
enumValues: [string, ...string[]];
|
|
39970
40788
|
baseColumn: never;
|
|
39971
40789
|
identity: undefined;
|
|
39972
40790
|
generated: undefined;
|
|
39973
40791
|
}, {}, {}>;
|
|
39974
|
-
|
|
39975
|
-
|
|
39976
|
-
|
|
39977
|
-
/**
|
|
39978
|
-
* File uploads during onboarding — logos, brand guides, creative assets.
|
|
39979
|
-
* Stored in Cloudflare R2 with prefix `flux-onboarding/`.
|
|
39980
|
-
*/
|
|
39981
|
-
export declare const fluxOnboardingFiles: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
39982
|
-
name: "flux_onboarding_files";
|
|
39983
|
-
schema: undefined;
|
|
39984
|
-
columns: {
|
|
39985
|
-
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
39986
|
-
name: "id";
|
|
39987
|
-
tableName: "flux_onboarding_files";
|
|
40792
|
+
requestedBy: import("drizzle-orm/pg-core").PgColumn<{
|
|
40793
|
+
name: "requested_by";
|
|
40794
|
+
tableName: "flux_client_approval_requests";
|
|
39988
40795
|
dataType: "string";
|
|
39989
40796
|
columnType: "PgText";
|
|
39990
40797
|
data: string;
|
|
39991
40798
|
driverParam: string;
|
|
39992
40799
|
notNull: true;
|
|
39993
|
-
hasDefault:
|
|
39994
|
-
isPrimaryKey:
|
|
40800
|
+
hasDefault: false;
|
|
40801
|
+
isPrimaryKey: false;
|
|
39995
40802
|
isAutoincrement: false;
|
|
39996
40803
|
hasRuntimeDefault: false;
|
|
39997
40804
|
enumValues: [string, ...string[]];
|
|
@@ -39999,31 +40806,31 @@ export declare const fluxOnboardingFiles: import("drizzle-orm/pg-core").PgTableW
|
|
|
39999
40806
|
identity: undefined;
|
|
40000
40807
|
generated: undefined;
|
|
40001
40808
|
}, {}, {}>;
|
|
40002
|
-
|
|
40003
|
-
name: "
|
|
40004
|
-
tableName: "
|
|
40005
|
-
dataType: "
|
|
40006
|
-
columnType: "
|
|
40007
|
-
data:
|
|
40809
|
+
requestedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
40810
|
+
name: "requested_at";
|
|
40811
|
+
tableName: "flux_client_approval_requests";
|
|
40812
|
+
dataType: "date";
|
|
40813
|
+
columnType: "PgTimestamp";
|
|
40814
|
+
data: Date;
|
|
40008
40815
|
driverParam: string;
|
|
40009
40816
|
notNull: true;
|
|
40010
|
-
hasDefault:
|
|
40817
|
+
hasDefault: true;
|
|
40011
40818
|
isPrimaryKey: false;
|
|
40012
40819
|
isAutoincrement: false;
|
|
40013
40820
|
hasRuntimeDefault: false;
|
|
40014
|
-
enumValues:
|
|
40821
|
+
enumValues: undefined;
|
|
40015
40822
|
baseColumn: never;
|
|
40016
40823
|
identity: undefined;
|
|
40017
40824
|
generated: undefined;
|
|
40018
40825
|
}, {}, {}>;
|
|
40019
|
-
|
|
40020
|
-
name: "
|
|
40021
|
-
tableName: "
|
|
40826
|
+
summaryMarkdown: import("drizzle-orm/pg-core").PgColumn<{
|
|
40827
|
+
name: "summary_markdown";
|
|
40828
|
+
tableName: "flux_client_approval_requests";
|
|
40022
40829
|
dataType: "string";
|
|
40023
40830
|
columnType: "PgText";
|
|
40024
40831
|
data: string;
|
|
40025
40832
|
driverParam: string;
|
|
40026
|
-
notNull:
|
|
40833
|
+
notNull: true;
|
|
40027
40834
|
hasDefault: false;
|
|
40028
40835
|
isPrimaryKey: false;
|
|
40029
40836
|
isAutoincrement: false;
|
|
@@ -40033,43 +40840,51 @@ export declare const fluxOnboardingFiles: import("drizzle-orm/pg-core").PgTableW
|
|
|
40033
40840
|
identity: undefined;
|
|
40034
40841
|
generated: undefined;
|
|
40035
40842
|
}, {}, {}>;
|
|
40036
|
-
|
|
40037
|
-
name: "
|
|
40038
|
-
tableName: "
|
|
40039
|
-
dataType: "
|
|
40040
|
-
columnType: "
|
|
40041
|
-
data:
|
|
40042
|
-
|
|
40843
|
+
attachmentsJson: import("drizzle-orm/pg-core").PgColumn<{
|
|
40844
|
+
name: "attachments_json";
|
|
40845
|
+
tableName: "flux_client_approval_requests";
|
|
40846
|
+
dataType: "json";
|
|
40847
|
+
columnType: "PgJsonb";
|
|
40848
|
+
data: {
|
|
40849
|
+
label: string;
|
|
40850
|
+
url: string;
|
|
40851
|
+
}[];
|
|
40852
|
+
driverParam: unknown;
|
|
40043
40853
|
notNull: false;
|
|
40044
40854
|
hasDefault: false;
|
|
40045
40855
|
isPrimaryKey: false;
|
|
40046
40856
|
isAutoincrement: false;
|
|
40047
40857
|
hasRuntimeDefault: false;
|
|
40048
|
-
enumValues:
|
|
40858
|
+
enumValues: undefined;
|
|
40049
40859
|
baseColumn: never;
|
|
40050
40860
|
identity: undefined;
|
|
40051
40861
|
generated: undefined;
|
|
40052
|
-
}, {}, {
|
|
40053
|
-
|
|
40054
|
-
|
|
40055
|
-
|
|
40862
|
+
}, {}, {
|
|
40863
|
+
$type: {
|
|
40864
|
+
label: string;
|
|
40865
|
+
url: string;
|
|
40866
|
+
}[];
|
|
40867
|
+
}>;
|
|
40868
|
+
status: import("drizzle-orm/pg-core").PgColumn<{
|
|
40869
|
+
name: "status";
|
|
40870
|
+
tableName: "flux_client_approval_requests";
|
|
40056
40871
|
dataType: "string";
|
|
40057
|
-
columnType: "
|
|
40058
|
-
data:
|
|
40872
|
+
columnType: "PgEnumColumn";
|
|
40873
|
+
data: "pending" | "expired" | "approved" | "changes_requested" | "canceled";
|
|
40059
40874
|
driverParam: string;
|
|
40060
40875
|
notNull: true;
|
|
40061
|
-
hasDefault:
|
|
40876
|
+
hasDefault: true;
|
|
40062
40877
|
isPrimaryKey: false;
|
|
40063
40878
|
isAutoincrement: false;
|
|
40064
40879
|
hasRuntimeDefault: false;
|
|
40065
|
-
enumValues: [
|
|
40880
|
+
enumValues: ["pending", "approved", "changes_requested", "expired", "canceled"];
|
|
40066
40881
|
baseColumn: never;
|
|
40067
40882
|
identity: undefined;
|
|
40068
40883
|
generated: undefined;
|
|
40069
40884
|
}, {}, {}>;
|
|
40070
|
-
|
|
40071
|
-
name: "
|
|
40072
|
-
tableName: "
|
|
40885
|
+
token: import("drizzle-orm/pg-core").PgColumn<{
|
|
40886
|
+
name: "token";
|
|
40887
|
+
tableName: "flux_client_approval_requests";
|
|
40073
40888
|
dataType: "string";
|
|
40074
40889
|
columnType: "PgText";
|
|
40075
40890
|
data: string;
|
|
@@ -40084,13 +40899,13 @@ export declare const fluxOnboardingFiles: import("drizzle-orm/pg-core").PgTableW
|
|
|
40084
40899
|
identity: undefined;
|
|
40085
40900
|
generated: undefined;
|
|
40086
40901
|
}, {}, {}>;
|
|
40087
|
-
|
|
40088
|
-
name: "
|
|
40089
|
-
tableName: "
|
|
40090
|
-
dataType: "
|
|
40091
|
-
columnType: "
|
|
40092
|
-
data:
|
|
40093
|
-
driverParam: string
|
|
40902
|
+
tokenExpiresAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
40903
|
+
name: "token_expires_at";
|
|
40904
|
+
tableName: "flux_client_approval_requests";
|
|
40905
|
+
dataType: "date";
|
|
40906
|
+
columnType: "PgTimestamp";
|
|
40907
|
+
data: Date;
|
|
40908
|
+
driverParam: string;
|
|
40094
40909
|
notNull: true;
|
|
40095
40910
|
hasDefault: false;
|
|
40096
40911
|
isPrimaryKey: false;
|
|
@@ -40101,31 +40916,31 @@ export declare const fluxOnboardingFiles: import("drizzle-orm/pg-core").PgTableW
|
|
|
40101
40916
|
identity: undefined;
|
|
40102
40917
|
generated: undefined;
|
|
40103
40918
|
}, {}, {}>;
|
|
40104
|
-
|
|
40105
|
-
name: "
|
|
40106
|
-
tableName: "
|
|
40107
|
-
dataType: "
|
|
40108
|
-
columnType: "
|
|
40109
|
-
data:
|
|
40919
|
+
approvedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
40920
|
+
name: "approved_at";
|
|
40921
|
+
tableName: "flux_client_approval_requests";
|
|
40922
|
+
dataType: "date";
|
|
40923
|
+
columnType: "PgTimestamp";
|
|
40924
|
+
data: Date;
|
|
40110
40925
|
driverParam: string;
|
|
40111
|
-
notNull:
|
|
40926
|
+
notNull: false;
|
|
40112
40927
|
hasDefault: false;
|
|
40113
40928
|
isPrimaryKey: false;
|
|
40114
40929
|
isAutoincrement: false;
|
|
40115
40930
|
hasRuntimeDefault: false;
|
|
40116
|
-
enumValues:
|
|
40931
|
+
enumValues: undefined;
|
|
40117
40932
|
baseColumn: never;
|
|
40118
40933
|
identity: undefined;
|
|
40119
40934
|
generated: undefined;
|
|
40120
40935
|
}, {}, {}>;
|
|
40121
|
-
|
|
40122
|
-
name: "
|
|
40123
|
-
tableName: "
|
|
40936
|
+
approvedBy: import("drizzle-orm/pg-core").PgColumn<{
|
|
40937
|
+
name: "approved_by";
|
|
40938
|
+
tableName: "flux_client_approval_requests";
|
|
40124
40939
|
dataType: "string";
|
|
40125
40940
|
columnType: "PgText";
|
|
40126
40941
|
data: string;
|
|
40127
40942
|
driverParam: string;
|
|
40128
|
-
notNull:
|
|
40943
|
+
notNull: false;
|
|
40129
40944
|
hasDefault: false;
|
|
40130
40945
|
isPrimaryKey: false;
|
|
40131
40946
|
isAutoincrement: false;
|
|
@@ -40135,43 +40950,60 @@ export declare const fluxOnboardingFiles: import("drizzle-orm/pg-core").PgTableW
|
|
|
40135
40950
|
identity: undefined;
|
|
40136
40951
|
generated: undefined;
|
|
40137
40952
|
}, {}, {}>;
|
|
40138
|
-
|
|
40139
|
-
name: "
|
|
40140
|
-
tableName: "
|
|
40953
|
+
responseMarkdown: import("drizzle-orm/pg-core").PgColumn<{
|
|
40954
|
+
name: "response_markdown";
|
|
40955
|
+
tableName: "flux_client_approval_requests";
|
|
40141
40956
|
dataType: "string";
|
|
40142
|
-
columnType: "
|
|
40143
|
-
data:
|
|
40957
|
+
columnType: "PgText";
|
|
40958
|
+
data: string;
|
|
40144
40959
|
driverParam: string;
|
|
40145
|
-
notNull:
|
|
40146
|
-
hasDefault:
|
|
40960
|
+
notNull: false;
|
|
40961
|
+
hasDefault: false;
|
|
40147
40962
|
isPrimaryKey: false;
|
|
40148
40963
|
isAutoincrement: false;
|
|
40149
40964
|
hasRuntimeDefault: false;
|
|
40150
|
-
enumValues: [
|
|
40965
|
+
enumValues: [string, ...string[]];
|
|
40151
40966
|
baseColumn: never;
|
|
40152
40967
|
identity: undefined;
|
|
40153
40968
|
generated: undefined;
|
|
40154
40969
|
}, {}, {}>;
|
|
40155
|
-
|
|
40156
|
-
name: "
|
|
40157
|
-
tableName: "
|
|
40158
|
-
dataType: "
|
|
40159
|
-
columnType: "
|
|
40160
|
-
data:
|
|
40970
|
+
respondedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
40971
|
+
name: "responded_at";
|
|
40972
|
+
tableName: "flux_client_approval_requests";
|
|
40973
|
+
dataType: "date";
|
|
40974
|
+
columnType: "PgTimestamp";
|
|
40975
|
+
data: Date;
|
|
40161
40976
|
driverParam: string;
|
|
40162
40977
|
notNull: false;
|
|
40163
40978
|
hasDefault: false;
|
|
40164
40979
|
isPrimaryKey: false;
|
|
40165
40980
|
isAutoincrement: false;
|
|
40166
40981
|
hasRuntimeDefault: false;
|
|
40167
|
-
enumValues:
|
|
40982
|
+
enumValues: undefined;
|
|
40168
40983
|
baseColumn: never;
|
|
40169
40984
|
identity: undefined;
|
|
40170
40985
|
generated: undefined;
|
|
40171
40986
|
}, {}, {}>;
|
|
40172
40987
|
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
40173
40988
|
name: "created_at";
|
|
40174
|
-
tableName: "
|
|
40989
|
+
tableName: "flux_client_approval_requests";
|
|
40990
|
+
dataType: "date";
|
|
40991
|
+
columnType: "PgTimestamp";
|
|
40992
|
+
data: Date;
|
|
40993
|
+
driverParam: string;
|
|
40994
|
+
notNull: true;
|
|
40995
|
+
hasDefault: true;
|
|
40996
|
+
isPrimaryKey: false;
|
|
40997
|
+
isAutoincrement: false;
|
|
40998
|
+
hasRuntimeDefault: false;
|
|
40999
|
+
enumValues: undefined;
|
|
41000
|
+
baseColumn: never;
|
|
41001
|
+
identity: undefined;
|
|
41002
|
+
generated: undefined;
|
|
41003
|
+
}, {}, {}>;
|
|
41004
|
+
updatedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
41005
|
+
name: "updated_at";
|
|
41006
|
+
tableName: "flux_client_approval_requests";
|
|
40175
41007
|
dataType: "date";
|
|
40176
41008
|
columnType: "PgTimestamp";
|
|
40177
41009
|
data: Date;
|
|
@@ -40189,17 +41021,15 @@ export declare const fluxOnboardingFiles: import("drizzle-orm/pg-core").PgTableW
|
|
|
40189
41021
|
};
|
|
40190
41022
|
dialect: "pg";
|
|
40191
41023
|
}>;
|
|
40192
|
-
|
|
40193
|
-
|
|
40194
|
-
|
|
40195
|
-
|
|
40196
|
-
export declare const fluxOnboardingActivity: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
40197
|
-
name: "flux_onboarding_activity";
|
|
41024
|
+
export declare const fluxClientApprovalEventKindEnum: import("drizzle-orm/pg-core").PgEnum<["requested", "email_sent", "email_failed", "viewed_by_client", "approved", "changes_requested", "expired", "canceled", "resent"]>;
|
|
41025
|
+
/** Audit trail — every state change records who/what/when. */
|
|
41026
|
+
export declare const fluxClientApprovalEvents: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
41027
|
+
name: "flux_client_approval_events";
|
|
40198
41028
|
schema: undefined;
|
|
40199
41029
|
columns: {
|
|
40200
41030
|
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
40201
41031
|
name: "id";
|
|
40202
|
-
tableName: "
|
|
41032
|
+
tableName: "flux_client_approval_events";
|
|
40203
41033
|
dataType: "string";
|
|
40204
41034
|
columnType: "PgText";
|
|
40205
41035
|
data: string;
|
|
@@ -40214,9 +41044,9 @@ export declare const fluxOnboardingActivity: import("drizzle-orm/pg-core").PgTab
|
|
|
40214
41044
|
identity: undefined;
|
|
40215
41045
|
generated: undefined;
|
|
40216
41046
|
}, {}, {}>;
|
|
40217
|
-
|
|
40218
|
-
name: "
|
|
40219
|
-
tableName: "
|
|
41047
|
+
approvalRequestId: import("drizzle-orm/pg-core").PgColumn<{
|
|
41048
|
+
name: "approval_request_id";
|
|
41049
|
+
tableName: "flux_client_approval_events";
|
|
40220
41050
|
dataType: "string";
|
|
40221
41051
|
columnType: "PgText";
|
|
40222
41052
|
data: string;
|
|
@@ -40231,31 +41061,31 @@ export declare const fluxOnboardingActivity: import("drizzle-orm/pg-core").PgTab
|
|
|
40231
41061
|
identity: undefined;
|
|
40232
41062
|
generated: undefined;
|
|
40233
41063
|
}, {}, {}>;
|
|
40234
|
-
|
|
40235
|
-
name: "
|
|
40236
|
-
tableName: "
|
|
41064
|
+
kind: import("drizzle-orm/pg-core").PgColumn<{
|
|
41065
|
+
name: "kind";
|
|
41066
|
+
tableName: "flux_client_approval_events";
|
|
40237
41067
|
dataType: "string";
|
|
40238
|
-
columnType: "
|
|
40239
|
-
data:
|
|
41068
|
+
columnType: "PgEnumColumn";
|
|
41069
|
+
data: "expired" | "approved" | "changes_requested" | "canceled" | "requested" | "email_sent" | "email_failed" | "viewed_by_client" | "resent";
|
|
40240
41070
|
driverParam: string;
|
|
40241
41071
|
notNull: true;
|
|
40242
41072
|
hasDefault: false;
|
|
40243
41073
|
isPrimaryKey: false;
|
|
40244
41074
|
isAutoincrement: false;
|
|
40245
41075
|
hasRuntimeDefault: false;
|
|
40246
|
-
enumValues: [
|
|
41076
|
+
enumValues: ["requested", "email_sent", "email_failed", "viewed_by_client", "approved", "changes_requested", "expired", "canceled", "resent"];
|
|
40247
41077
|
baseColumn: never;
|
|
40248
41078
|
identity: undefined;
|
|
40249
41079
|
generated: undefined;
|
|
40250
41080
|
}, {}, {}>;
|
|
40251
|
-
|
|
40252
|
-
name: "
|
|
40253
|
-
tableName: "
|
|
41081
|
+
note: import("drizzle-orm/pg-core").PgColumn<{
|
|
41082
|
+
name: "note";
|
|
41083
|
+
tableName: "flux_client_approval_events";
|
|
40254
41084
|
dataType: "string";
|
|
40255
41085
|
columnType: "PgText";
|
|
40256
41086
|
data: string;
|
|
40257
41087
|
driverParam: string;
|
|
40258
|
-
notNull:
|
|
41088
|
+
notNull: false;
|
|
40259
41089
|
hasDefault: false;
|
|
40260
41090
|
isPrimaryKey: false;
|
|
40261
41091
|
isAutoincrement: false;
|
|
@@ -40265,32 +41095,32 @@ export declare const fluxOnboardingActivity: import("drizzle-orm/pg-core").PgTab
|
|
|
40265
41095
|
identity: undefined;
|
|
40266
41096
|
generated: undefined;
|
|
40267
41097
|
}, {}, {}>;
|
|
40268
|
-
|
|
40269
|
-
name: "
|
|
40270
|
-
tableName: "
|
|
41098
|
+
actorId: import("drizzle-orm/pg-core").PgColumn<{
|
|
41099
|
+
name: "actor_id";
|
|
41100
|
+
tableName: "flux_client_approval_events";
|
|
40271
41101
|
dataType: "string";
|
|
40272
|
-
columnType: "
|
|
40273
|
-
data:
|
|
41102
|
+
columnType: "PgText";
|
|
41103
|
+
data: string;
|
|
40274
41104
|
driverParam: string;
|
|
40275
|
-
notNull:
|
|
41105
|
+
notNull: false;
|
|
40276
41106
|
hasDefault: false;
|
|
40277
41107
|
isPrimaryKey: false;
|
|
40278
41108
|
isAutoincrement: false;
|
|
40279
41109
|
hasRuntimeDefault: false;
|
|
40280
|
-
enumValues: [
|
|
41110
|
+
enumValues: [string, ...string[]];
|
|
40281
41111
|
baseColumn: never;
|
|
40282
41112
|
identity: undefined;
|
|
40283
41113
|
generated: undefined;
|
|
40284
41114
|
}, {}, {}>;
|
|
40285
41115
|
metadata: import("drizzle-orm/pg-core").PgColumn<{
|
|
40286
41116
|
name: "metadata";
|
|
40287
|
-
tableName: "
|
|
41117
|
+
tableName: "flux_client_approval_events";
|
|
40288
41118
|
dataType: "json";
|
|
40289
41119
|
columnType: "PgJsonb";
|
|
40290
41120
|
data: Record<string, unknown>;
|
|
40291
41121
|
driverParam: unknown;
|
|
40292
41122
|
notNull: false;
|
|
40293
|
-
hasDefault:
|
|
41123
|
+
hasDefault: false;
|
|
40294
41124
|
isPrimaryKey: false;
|
|
40295
41125
|
isAutoincrement: false;
|
|
40296
41126
|
hasRuntimeDefault: false;
|
|
@@ -40303,7 +41133,7 @@ export declare const fluxOnboardingActivity: import("drizzle-orm/pg-core").PgTab
|
|
|
40303
41133
|
}>;
|
|
40304
41134
|
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
40305
41135
|
name: "created_at";
|
|
40306
|
-
tableName: "
|
|
41136
|
+
tableName: "flux_client_approval_events";
|
|
40307
41137
|
dataType: "date";
|
|
40308
41138
|
columnType: "PgTimestamp";
|
|
40309
41139
|
data: Date;
|
|
@@ -40321,43 +41151,16 @@ export declare const fluxOnboardingActivity: import("drizzle-orm/pg-core").PgTab
|
|
|
40321
41151
|
};
|
|
40322
41152
|
dialect: "pg";
|
|
40323
41153
|
}>;
|
|
40324
|
-
export declare const
|
|
40325
|
-
|
|
40326
|
-
|
|
40327
|
-
createdByUser: import("drizzle-orm").One<"flux_users", false>;
|
|
40328
|
-
renewalParent: import("drizzle-orm").One<"flux_onboardings", false>;
|
|
40329
|
-
renewalChildren: import("drizzle-orm").Many<"flux_onboardings">;
|
|
40330
|
-
sections: import("drizzle-orm").Many<"flux_onboarding_sections">;
|
|
40331
|
-
files: import("drizzle-orm").Many<"flux_onboarding_files">;
|
|
40332
|
-
activity: import("drizzle-orm").Many<"flux_onboarding_activity">;
|
|
40333
|
-
}>;
|
|
40334
|
-
export declare const fluxOnboardingSectionsRelations: import("drizzle-orm").Relations<"flux_onboarding_sections", {
|
|
40335
|
-
onboarding: import("drizzle-orm").One<"flux_onboardings", true>;
|
|
40336
|
-
reviewedByUser: import("drizzle-orm").One<"flux_users", false>;
|
|
40337
|
-
responses: import("drizzle-orm").Many<"flux_onboarding_responses">;
|
|
40338
|
-
files: import("drizzle-orm").Many<"flux_onboarding_files">;
|
|
40339
|
-
}>;
|
|
40340
|
-
export declare const fluxOnboardingResponsesRelations: import("drizzle-orm").Relations<"flux_onboarding_responses", {
|
|
40341
|
-
section: import("drizzle-orm").One<"flux_onboarding_sections", true>;
|
|
40342
|
-
files: import("drizzle-orm").Many<"flux_onboarding_files">;
|
|
40343
|
-
}>;
|
|
40344
|
-
export declare const fluxOnboardingFilesRelations: import("drizzle-orm").Relations<"flux_onboarding_files", {
|
|
40345
|
-
onboarding: import("drizzle-orm").One<"flux_onboardings", true>;
|
|
40346
|
-
section: import("drizzle-orm").One<"flux_onboarding_sections", false>;
|
|
40347
|
-
response: import("drizzle-orm").One<"flux_onboarding_responses", false>;
|
|
41154
|
+
export declare const fluxClientApprovalRequestsRelations: import("drizzle-orm").Relations<"flux_client_approval_requests", {
|
|
41155
|
+
account: import("drizzle-orm").One<"flux_client_accounts", true>;
|
|
41156
|
+
events: import("drizzle-orm").Many<"flux_client_approval_events">;
|
|
40348
41157
|
}>;
|
|
40349
|
-
export declare const
|
|
40350
|
-
|
|
41158
|
+
export declare const fluxClientApprovalEventsRelations: import("drizzle-orm").Relations<"flux_client_approval_events", {
|
|
41159
|
+
request: import("drizzle-orm").One<"flux_client_approval_requests", true>;
|
|
40351
41160
|
}>;
|
|
40352
|
-
export type
|
|
40353
|
-
export type
|
|
40354
|
-
export type
|
|
40355
|
-
export type
|
|
40356
|
-
export type FluxOnboardingResponse = typeof fluxOnboardingResponses.$inferSelect;
|
|
40357
|
-
export type NewFluxOnboardingResponse = typeof fluxOnboardingResponses.$inferInsert;
|
|
40358
|
-
export type FluxOnboardingFile = typeof fluxOnboardingFiles.$inferSelect;
|
|
40359
|
-
export type NewFluxOnboardingFile = typeof fluxOnboardingFiles.$inferInsert;
|
|
40360
|
-
export type FluxOnboardingActivityRecord = typeof fluxOnboardingActivity.$inferSelect;
|
|
40361
|
-
export type NewFluxOnboardingActivityRecord = typeof fluxOnboardingActivity.$inferInsert;
|
|
41161
|
+
export type FluxClientApprovalRequest = typeof fluxClientApprovalRequests.$inferSelect;
|
|
41162
|
+
export type NewFluxClientApprovalRequest = typeof fluxClientApprovalRequests.$inferInsert;
|
|
41163
|
+
export type FluxClientApprovalEvent = typeof fluxClientApprovalEvents.$inferSelect;
|
|
41164
|
+
export type NewFluxClientApprovalEvent = typeof fluxClientApprovalEvents.$inferInsert;
|
|
40362
41165
|
export {};
|
|
40363
41166
|
//# sourceMappingURL=schema.d.ts.map
|