@valentine-efagene/qshelter-common 2.0.29 → 2.0.31
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/generated/client/browser.d.ts +20 -0
- package/dist/generated/client/client.d.ts +20 -0
- package/dist/generated/client/commonInputTypes.d.ts +531 -51
- package/dist/generated/client/enums.d.ts +133 -0
- package/dist/generated/client/enums.js +117 -0
- package/dist/generated/client/internal/class.d.ts +44 -0
- package/dist/generated/client/internal/class.js +2 -2
- package/dist/generated/client/internal/prismaNamespace.d.ts +478 -35
- package/dist/generated/client/internal/prismaNamespace.js +139 -36
- package/dist/generated/client/internal/prismaNamespaceBrowser.d.ts +146 -35
- package/dist/generated/client/internal/prismaNamespaceBrowser.js +139 -36
- package/dist/generated/client/models/Contract.d.ts +423 -148
- package/dist/generated/client/models/ContractDocument.d.ts +32 -28
- package/dist/generated/client/models/ContractInstallment.d.ts +30 -26
- package/dist/generated/client/models/ContractPayment.d.ts +44 -40
- package/dist/generated/client/models/ContractPhase.d.ts +539 -121
- package/dist/generated/client/models/ContractPhaseStep.d.ts +208 -108
- package/dist/generated/client/models/ContractPhaseStepApproval.d.ts +32 -28
- package/dist/generated/client/models/ContractPhaseStepDocument.d.ts +1052 -0
- package/dist/generated/client/models/ContractPhaseStepDocument.js +1 -0
- package/dist/generated/client/models/ContractTermination.d.ts +3449 -0
- package/dist/generated/client/models/ContractTermination.js +1 -0
- package/dist/generated/client/models/PaymentMethodPhaseDocument.d.ts +1216 -0
- package/dist/generated/client/models/PaymentMethodPhaseDocument.js +1 -0
- package/dist/generated/client/models/PaymentMethodPhaseStep.d.ts +1187 -0
- package/dist/generated/client/models/PaymentMethodPhaseStep.js +1 -0
- package/dist/generated/client/models/PaymentPlan.d.ts +34 -30
- package/dist/generated/client/models/PropertyPaymentMethodPhase.d.ts +504 -135
- package/dist/generated/client/models/Tenant.d.ts +163 -0
- package/dist/generated/client/models/User.d.ts +586 -0
- package/dist/generated/client/models/index.d.ts +4 -0
- package/dist/generated/client/models/index.js +4 -0
- package/dist/generated/client/models.d.ts +4 -0
- package/package.json +1 -1
- package/prisma/migrations/20260101081428_normalize_schema/migration.sql +119 -0
- package/prisma/migrations/20260101102022_add_contract_termination/migration.sql +69 -0
- package/prisma/schema.prisma +340 -30
|
@@ -224,8 +224,41 @@ export type IntNullableWithAggregatesFilter<$PrismaModel = never> = {
|
|
|
224
224
|
_min?: Prisma.NestedIntNullableFilter<$PrismaModel>;
|
|
225
225
|
_max?: Prisma.NestedIntNullableFilter<$PrismaModel>;
|
|
226
226
|
};
|
|
227
|
-
export type
|
|
228
|
-
|
|
227
|
+
export type EnumPaymentFrequencyFilter<$PrismaModel = never> = {
|
|
228
|
+
equals?: $Enums.PaymentFrequency | Prisma.EnumPaymentFrequencyFieldRefInput<$PrismaModel>;
|
|
229
|
+
in?: $Enums.PaymentFrequency[];
|
|
230
|
+
notIn?: $Enums.PaymentFrequency[];
|
|
231
|
+
not?: Prisma.NestedEnumPaymentFrequencyFilter<$PrismaModel> | $Enums.PaymentFrequency;
|
|
232
|
+
};
|
|
233
|
+
export type EnumPaymentFrequencyWithAggregatesFilter<$PrismaModel = never> = {
|
|
234
|
+
equals?: $Enums.PaymentFrequency | Prisma.EnumPaymentFrequencyFieldRefInput<$PrismaModel>;
|
|
235
|
+
in?: $Enums.PaymentFrequency[];
|
|
236
|
+
notIn?: $Enums.PaymentFrequency[];
|
|
237
|
+
not?: Prisma.NestedEnumPaymentFrequencyWithAggregatesFilter<$PrismaModel> | $Enums.PaymentFrequency;
|
|
238
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
239
|
+
_min?: Prisma.NestedEnumPaymentFrequencyFilter<$PrismaModel>;
|
|
240
|
+
_max?: Prisma.NestedEnumPaymentFrequencyFilter<$PrismaModel>;
|
|
241
|
+
};
|
|
242
|
+
export type EnumPhaseCategoryFilter<$PrismaModel = never> = {
|
|
243
|
+
equals?: $Enums.PhaseCategory | Prisma.EnumPhaseCategoryFieldRefInput<$PrismaModel>;
|
|
244
|
+
in?: $Enums.PhaseCategory[];
|
|
245
|
+
notIn?: $Enums.PhaseCategory[];
|
|
246
|
+
not?: Prisma.NestedEnumPhaseCategoryFilter<$PrismaModel> | $Enums.PhaseCategory;
|
|
247
|
+
};
|
|
248
|
+
export type EnumPhaseTypeFilter<$PrismaModel = never> = {
|
|
249
|
+
equals?: $Enums.PhaseType | Prisma.EnumPhaseTypeFieldRefInput<$PrismaModel>;
|
|
250
|
+
in?: $Enums.PhaseType[];
|
|
251
|
+
notIn?: $Enums.PhaseType[];
|
|
252
|
+
not?: Prisma.NestedEnumPhaseTypeFilter<$PrismaModel> | $Enums.PhaseType;
|
|
253
|
+
};
|
|
254
|
+
export type EnumCompletionCriterionNullableFilter<$PrismaModel = never> = {
|
|
255
|
+
equals?: $Enums.CompletionCriterion | Prisma.EnumCompletionCriterionFieldRefInput<$PrismaModel> | null;
|
|
256
|
+
in?: $Enums.CompletionCriterion[] | null;
|
|
257
|
+
notIn?: $Enums.CompletionCriterion[] | null;
|
|
258
|
+
not?: Prisma.NestedEnumCompletionCriterionNullableFilter<$PrismaModel> | $Enums.CompletionCriterion | null;
|
|
259
|
+
};
|
|
260
|
+
export type JsonNullableFilter<$PrismaModel = never> = Prisma.PatchUndefined<Prisma.Either<Required<JsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>, Required<JsonNullableFilterBase<$PrismaModel>>> | Prisma.OptionalFlat<Omit<Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>;
|
|
261
|
+
export type JsonNullableFilterBase<$PrismaModel = never> = {
|
|
229
262
|
equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter;
|
|
230
263
|
path?: string;
|
|
231
264
|
mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel>;
|
|
@@ -241,14 +274,35 @@ export type JsonFilterBase<$PrismaModel = never> = {
|
|
|
241
274
|
gte?: runtime.InputJsonValue;
|
|
242
275
|
not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter;
|
|
243
276
|
};
|
|
244
|
-
export type
|
|
245
|
-
equals?: $Enums.
|
|
246
|
-
in?: $Enums.
|
|
247
|
-
notIn?: $Enums.
|
|
248
|
-
not?: Prisma.
|
|
277
|
+
export type EnumPhaseCategoryWithAggregatesFilter<$PrismaModel = never> = {
|
|
278
|
+
equals?: $Enums.PhaseCategory | Prisma.EnumPhaseCategoryFieldRefInput<$PrismaModel>;
|
|
279
|
+
in?: $Enums.PhaseCategory[];
|
|
280
|
+
notIn?: $Enums.PhaseCategory[];
|
|
281
|
+
not?: Prisma.NestedEnumPhaseCategoryWithAggregatesFilter<$PrismaModel> | $Enums.PhaseCategory;
|
|
282
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
283
|
+
_min?: Prisma.NestedEnumPhaseCategoryFilter<$PrismaModel>;
|
|
284
|
+
_max?: Prisma.NestedEnumPhaseCategoryFilter<$PrismaModel>;
|
|
249
285
|
};
|
|
250
|
-
export type
|
|
251
|
-
|
|
286
|
+
export type EnumPhaseTypeWithAggregatesFilter<$PrismaModel = never> = {
|
|
287
|
+
equals?: $Enums.PhaseType | Prisma.EnumPhaseTypeFieldRefInput<$PrismaModel>;
|
|
288
|
+
in?: $Enums.PhaseType[];
|
|
289
|
+
notIn?: $Enums.PhaseType[];
|
|
290
|
+
not?: Prisma.NestedEnumPhaseTypeWithAggregatesFilter<$PrismaModel> | $Enums.PhaseType;
|
|
291
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
292
|
+
_min?: Prisma.NestedEnumPhaseTypeFilter<$PrismaModel>;
|
|
293
|
+
_max?: Prisma.NestedEnumPhaseTypeFilter<$PrismaModel>;
|
|
294
|
+
};
|
|
295
|
+
export type EnumCompletionCriterionNullableWithAggregatesFilter<$PrismaModel = never> = {
|
|
296
|
+
equals?: $Enums.CompletionCriterion | Prisma.EnumCompletionCriterionFieldRefInput<$PrismaModel> | null;
|
|
297
|
+
in?: $Enums.CompletionCriterion[] | null;
|
|
298
|
+
notIn?: $Enums.CompletionCriterion[] | null;
|
|
299
|
+
not?: Prisma.NestedEnumCompletionCriterionNullableWithAggregatesFilter<$PrismaModel> | $Enums.CompletionCriterion | null;
|
|
300
|
+
_count?: Prisma.NestedIntNullableFilter<$PrismaModel>;
|
|
301
|
+
_min?: Prisma.NestedEnumCompletionCriterionNullableFilter<$PrismaModel>;
|
|
302
|
+
_max?: Prisma.NestedEnumCompletionCriterionNullableFilter<$PrismaModel>;
|
|
303
|
+
};
|
|
304
|
+
export type JsonNullableWithAggregatesFilter<$PrismaModel = never> = Prisma.PatchUndefined<Prisma.Either<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>>, Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>> | Prisma.OptionalFlat<Omit<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>>;
|
|
305
|
+
export type JsonNullableWithAggregatesFilterBase<$PrismaModel = never> = {
|
|
252
306
|
equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter;
|
|
253
307
|
path?: string;
|
|
254
308
|
mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel>;
|
|
@@ -263,21 +317,150 @@ export type JsonWithAggregatesFilterBase<$PrismaModel = never> = {
|
|
|
263
317
|
gt?: runtime.InputJsonValue;
|
|
264
318
|
gte?: runtime.InputJsonValue;
|
|
265
319
|
not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter;
|
|
320
|
+
_count?: Prisma.NestedIntNullableFilter<$PrismaModel>;
|
|
321
|
+
_min?: Prisma.NestedJsonNullableFilter<$PrismaModel>;
|
|
322
|
+
_max?: Prisma.NestedJsonNullableFilter<$PrismaModel>;
|
|
323
|
+
};
|
|
324
|
+
export type EnumStepTypeFilter<$PrismaModel = never> = {
|
|
325
|
+
equals?: $Enums.StepType | Prisma.EnumStepTypeFieldRefInput<$PrismaModel>;
|
|
326
|
+
in?: $Enums.StepType[];
|
|
327
|
+
notIn?: $Enums.StepType[];
|
|
328
|
+
not?: Prisma.NestedEnumStepTypeFilter<$PrismaModel> | $Enums.StepType;
|
|
329
|
+
};
|
|
330
|
+
export type EnumStepTypeWithAggregatesFilter<$PrismaModel = never> = {
|
|
331
|
+
equals?: $Enums.StepType | Prisma.EnumStepTypeFieldRefInput<$PrismaModel>;
|
|
332
|
+
in?: $Enums.StepType[];
|
|
333
|
+
notIn?: $Enums.StepType[];
|
|
334
|
+
not?: Prisma.NestedEnumStepTypeWithAggregatesFilter<$PrismaModel> | $Enums.StepType;
|
|
266
335
|
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
267
|
-
_min?: Prisma.
|
|
268
|
-
_max?: Prisma.
|
|
336
|
+
_min?: Prisma.NestedEnumStepTypeFilter<$PrismaModel>;
|
|
337
|
+
_max?: Prisma.NestedEnumStepTypeFilter<$PrismaModel>;
|
|
269
338
|
};
|
|
270
|
-
export type
|
|
271
|
-
equals?: $Enums.
|
|
272
|
-
in?: $Enums.
|
|
273
|
-
notIn?: $Enums.
|
|
274
|
-
not?: Prisma.
|
|
339
|
+
export type EnumContractStatusFilter<$PrismaModel = never> = {
|
|
340
|
+
equals?: $Enums.ContractStatus | Prisma.EnumContractStatusFieldRefInput<$PrismaModel>;
|
|
341
|
+
in?: $Enums.ContractStatus[];
|
|
342
|
+
notIn?: $Enums.ContractStatus[];
|
|
343
|
+
not?: Prisma.NestedEnumContractStatusFilter<$PrismaModel> | $Enums.ContractStatus;
|
|
344
|
+
};
|
|
345
|
+
export type EnumContractStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
346
|
+
equals?: $Enums.ContractStatus | Prisma.EnumContractStatusFieldRefInput<$PrismaModel>;
|
|
347
|
+
in?: $Enums.ContractStatus[];
|
|
348
|
+
notIn?: $Enums.ContractStatus[];
|
|
349
|
+
not?: Prisma.NestedEnumContractStatusWithAggregatesFilter<$PrismaModel> | $Enums.ContractStatus;
|
|
275
350
|
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
276
|
-
_min?: Prisma.
|
|
277
|
-
_max?: Prisma.
|
|
351
|
+
_min?: Prisma.NestedEnumContractStatusFilter<$PrismaModel>;
|
|
352
|
+
_max?: Prisma.NestedEnumContractStatusFilter<$PrismaModel>;
|
|
278
353
|
};
|
|
279
|
-
export type
|
|
280
|
-
|
|
354
|
+
export type EnumPhaseStatusFilter<$PrismaModel = never> = {
|
|
355
|
+
equals?: $Enums.PhaseStatus | Prisma.EnumPhaseStatusFieldRefInput<$PrismaModel>;
|
|
356
|
+
in?: $Enums.PhaseStatus[];
|
|
357
|
+
notIn?: $Enums.PhaseStatus[];
|
|
358
|
+
not?: Prisma.NestedEnumPhaseStatusFilter<$PrismaModel> | $Enums.PhaseStatus;
|
|
359
|
+
};
|
|
360
|
+
export type EnumPhaseStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
361
|
+
equals?: $Enums.PhaseStatus | Prisma.EnumPhaseStatusFieldRefInput<$PrismaModel>;
|
|
362
|
+
in?: $Enums.PhaseStatus[];
|
|
363
|
+
notIn?: $Enums.PhaseStatus[];
|
|
364
|
+
not?: Prisma.NestedEnumPhaseStatusWithAggregatesFilter<$PrismaModel> | $Enums.PhaseStatus;
|
|
365
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
366
|
+
_min?: Prisma.NestedEnumPhaseStatusFilter<$PrismaModel>;
|
|
367
|
+
_max?: Prisma.NestedEnumPhaseStatusFilter<$PrismaModel>;
|
|
368
|
+
};
|
|
369
|
+
export type EnumStepStatusFilter<$PrismaModel = never> = {
|
|
370
|
+
equals?: $Enums.StepStatus | Prisma.EnumStepStatusFieldRefInput<$PrismaModel>;
|
|
371
|
+
in?: $Enums.StepStatus[];
|
|
372
|
+
notIn?: $Enums.StepStatus[];
|
|
373
|
+
not?: Prisma.NestedEnumStepStatusFilter<$PrismaModel> | $Enums.StepStatus;
|
|
374
|
+
};
|
|
375
|
+
export type EnumStepStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
376
|
+
equals?: $Enums.StepStatus | Prisma.EnumStepStatusFieldRefInput<$PrismaModel>;
|
|
377
|
+
in?: $Enums.StepStatus[];
|
|
378
|
+
notIn?: $Enums.StepStatus[];
|
|
379
|
+
not?: Prisma.NestedEnumStepStatusWithAggregatesFilter<$PrismaModel> | $Enums.StepStatus;
|
|
380
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
381
|
+
_min?: Prisma.NestedEnumStepStatusFilter<$PrismaModel>;
|
|
382
|
+
_max?: Prisma.NestedEnumStepStatusFilter<$PrismaModel>;
|
|
383
|
+
};
|
|
384
|
+
export type EnumApprovalDecisionFilter<$PrismaModel = never> = {
|
|
385
|
+
equals?: $Enums.ApprovalDecision | Prisma.EnumApprovalDecisionFieldRefInput<$PrismaModel>;
|
|
386
|
+
in?: $Enums.ApprovalDecision[];
|
|
387
|
+
notIn?: $Enums.ApprovalDecision[];
|
|
388
|
+
not?: Prisma.NestedEnumApprovalDecisionFilter<$PrismaModel> | $Enums.ApprovalDecision;
|
|
389
|
+
};
|
|
390
|
+
export type EnumApprovalDecisionWithAggregatesFilter<$PrismaModel = never> = {
|
|
391
|
+
equals?: $Enums.ApprovalDecision | Prisma.EnumApprovalDecisionFieldRefInput<$PrismaModel>;
|
|
392
|
+
in?: $Enums.ApprovalDecision[];
|
|
393
|
+
notIn?: $Enums.ApprovalDecision[];
|
|
394
|
+
not?: Prisma.NestedEnumApprovalDecisionWithAggregatesFilter<$PrismaModel> | $Enums.ApprovalDecision;
|
|
395
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
396
|
+
_min?: Prisma.NestedEnumApprovalDecisionFilter<$PrismaModel>;
|
|
397
|
+
_max?: Prisma.NestedEnumApprovalDecisionFilter<$PrismaModel>;
|
|
398
|
+
};
|
|
399
|
+
export type EnumInstallmentStatusFilter<$PrismaModel = never> = {
|
|
400
|
+
equals?: $Enums.InstallmentStatus | Prisma.EnumInstallmentStatusFieldRefInput<$PrismaModel>;
|
|
401
|
+
in?: $Enums.InstallmentStatus[];
|
|
402
|
+
notIn?: $Enums.InstallmentStatus[];
|
|
403
|
+
not?: Prisma.NestedEnumInstallmentStatusFilter<$PrismaModel> | $Enums.InstallmentStatus;
|
|
404
|
+
};
|
|
405
|
+
export type EnumInstallmentStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
406
|
+
equals?: $Enums.InstallmentStatus | Prisma.EnumInstallmentStatusFieldRefInput<$PrismaModel>;
|
|
407
|
+
in?: $Enums.InstallmentStatus[];
|
|
408
|
+
notIn?: $Enums.InstallmentStatus[];
|
|
409
|
+
not?: Prisma.NestedEnumInstallmentStatusWithAggregatesFilter<$PrismaModel> | $Enums.InstallmentStatus;
|
|
410
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
411
|
+
_min?: Prisma.NestedEnumInstallmentStatusFilter<$PrismaModel>;
|
|
412
|
+
_max?: Prisma.NestedEnumInstallmentStatusFilter<$PrismaModel>;
|
|
413
|
+
};
|
|
414
|
+
export type EnumPaymentStatusFilter<$PrismaModel = never> = {
|
|
415
|
+
equals?: $Enums.PaymentStatus | Prisma.EnumPaymentStatusFieldRefInput<$PrismaModel>;
|
|
416
|
+
in?: $Enums.PaymentStatus[];
|
|
417
|
+
notIn?: $Enums.PaymentStatus[];
|
|
418
|
+
not?: Prisma.NestedEnumPaymentStatusFilter<$PrismaModel> | $Enums.PaymentStatus;
|
|
419
|
+
};
|
|
420
|
+
export type EnumPaymentStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
421
|
+
equals?: $Enums.PaymentStatus | Prisma.EnumPaymentStatusFieldRefInput<$PrismaModel>;
|
|
422
|
+
in?: $Enums.PaymentStatus[];
|
|
423
|
+
notIn?: $Enums.PaymentStatus[];
|
|
424
|
+
not?: Prisma.NestedEnumPaymentStatusWithAggregatesFilter<$PrismaModel> | $Enums.PaymentStatus;
|
|
425
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
426
|
+
_min?: Prisma.NestedEnumPaymentStatusFilter<$PrismaModel>;
|
|
427
|
+
_max?: Prisma.NestedEnumPaymentStatusFilter<$PrismaModel>;
|
|
428
|
+
};
|
|
429
|
+
export type EnumDocumentStatusFilter<$PrismaModel = never> = {
|
|
430
|
+
equals?: $Enums.DocumentStatus | Prisma.EnumDocumentStatusFieldRefInput<$PrismaModel>;
|
|
431
|
+
in?: $Enums.DocumentStatus[];
|
|
432
|
+
notIn?: $Enums.DocumentStatus[];
|
|
433
|
+
not?: Prisma.NestedEnumDocumentStatusFilter<$PrismaModel> | $Enums.DocumentStatus;
|
|
434
|
+
};
|
|
435
|
+
export type EnumDocumentStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
436
|
+
equals?: $Enums.DocumentStatus | Prisma.EnumDocumentStatusFieldRefInput<$PrismaModel>;
|
|
437
|
+
in?: $Enums.DocumentStatus[];
|
|
438
|
+
notIn?: $Enums.DocumentStatus[];
|
|
439
|
+
not?: Prisma.NestedEnumDocumentStatusWithAggregatesFilter<$PrismaModel> | $Enums.DocumentStatus;
|
|
440
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
441
|
+
_min?: Prisma.NestedEnumDocumentStatusFilter<$PrismaModel>;
|
|
442
|
+
_max?: Prisma.NestedEnumDocumentStatusFilter<$PrismaModel>;
|
|
443
|
+
};
|
|
444
|
+
export type EnumTerminationInitiatorFilter<$PrismaModel = never> = {
|
|
445
|
+
equals?: $Enums.TerminationInitiator | Prisma.EnumTerminationInitiatorFieldRefInput<$PrismaModel>;
|
|
446
|
+
in?: $Enums.TerminationInitiator[];
|
|
447
|
+
notIn?: $Enums.TerminationInitiator[];
|
|
448
|
+
not?: Prisma.NestedEnumTerminationInitiatorFilter<$PrismaModel> | $Enums.TerminationInitiator;
|
|
449
|
+
};
|
|
450
|
+
export type EnumTerminationTypeFilter<$PrismaModel = never> = {
|
|
451
|
+
equals?: $Enums.TerminationType | Prisma.EnumTerminationTypeFieldRefInput<$PrismaModel>;
|
|
452
|
+
in?: $Enums.TerminationType[];
|
|
453
|
+
notIn?: $Enums.TerminationType[];
|
|
454
|
+
not?: Prisma.NestedEnumTerminationTypeFilter<$PrismaModel> | $Enums.TerminationType;
|
|
455
|
+
};
|
|
456
|
+
export type EnumTerminationStatusFilter<$PrismaModel = never> = {
|
|
457
|
+
equals?: $Enums.TerminationStatus | Prisma.EnumTerminationStatusFieldRefInput<$PrismaModel>;
|
|
458
|
+
in?: $Enums.TerminationStatus[];
|
|
459
|
+
notIn?: $Enums.TerminationStatus[];
|
|
460
|
+
not?: Prisma.NestedEnumTerminationStatusFilter<$PrismaModel> | $Enums.TerminationStatus;
|
|
461
|
+
};
|
|
462
|
+
export type JsonFilter<$PrismaModel = never> = Prisma.PatchUndefined<Prisma.Either<Required<JsonFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonFilterBase<$PrismaModel>>, 'path'>>, Required<JsonFilterBase<$PrismaModel>>> | Prisma.OptionalFlat<Omit<Required<JsonFilterBase<$PrismaModel>>, 'path'>>;
|
|
463
|
+
export type JsonFilterBase<$PrismaModel = never> = {
|
|
281
464
|
equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter;
|
|
282
465
|
path?: string;
|
|
283
466
|
mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel>;
|
|
@@ -293,14 +476,41 @@ export type JsonNullableFilterBase<$PrismaModel = never> = {
|
|
|
293
476
|
gte?: runtime.InputJsonValue;
|
|
294
477
|
not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter;
|
|
295
478
|
};
|
|
296
|
-
export type
|
|
297
|
-
equals?: $Enums.
|
|
298
|
-
in?: $Enums.
|
|
299
|
-
notIn?: $Enums.
|
|
300
|
-
not?: Prisma.
|
|
479
|
+
export type EnumRefundStatusFilter<$PrismaModel = never> = {
|
|
480
|
+
equals?: $Enums.RefundStatus | Prisma.EnumRefundStatusFieldRefInput<$PrismaModel>;
|
|
481
|
+
in?: $Enums.RefundStatus[];
|
|
482
|
+
notIn?: $Enums.RefundStatus[];
|
|
483
|
+
not?: Prisma.NestedEnumRefundStatusFilter<$PrismaModel> | $Enums.RefundStatus;
|
|
301
484
|
};
|
|
302
|
-
export type
|
|
303
|
-
|
|
485
|
+
export type EnumTerminationInitiatorWithAggregatesFilter<$PrismaModel = never> = {
|
|
486
|
+
equals?: $Enums.TerminationInitiator | Prisma.EnumTerminationInitiatorFieldRefInput<$PrismaModel>;
|
|
487
|
+
in?: $Enums.TerminationInitiator[];
|
|
488
|
+
notIn?: $Enums.TerminationInitiator[];
|
|
489
|
+
not?: Prisma.NestedEnumTerminationInitiatorWithAggregatesFilter<$PrismaModel> | $Enums.TerminationInitiator;
|
|
490
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
491
|
+
_min?: Prisma.NestedEnumTerminationInitiatorFilter<$PrismaModel>;
|
|
492
|
+
_max?: Prisma.NestedEnumTerminationInitiatorFilter<$PrismaModel>;
|
|
493
|
+
};
|
|
494
|
+
export type EnumTerminationTypeWithAggregatesFilter<$PrismaModel = never> = {
|
|
495
|
+
equals?: $Enums.TerminationType | Prisma.EnumTerminationTypeFieldRefInput<$PrismaModel>;
|
|
496
|
+
in?: $Enums.TerminationType[];
|
|
497
|
+
notIn?: $Enums.TerminationType[];
|
|
498
|
+
not?: Prisma.NestedEnumTerminationTypeWithAggregatesFilter<$PrismaModel> | $Enums.TerminationType;
|
|
499
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
500
|
+
_min?: Prisma.NestedEnumTerminationTypeFilter<$PrismaModel>;
|
|
501
|
+
_max?: Prisma.NestedEnumTerminationTypeFilter<$PrismaModel>;
|
|
502
|
+
};
|
|
503
|
+
export type EnumTerminationStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
504
|
+
equals?: $Enums.TerminationStatus | Prisma.EnumTerminationStatusFieldRefInput<$PrismaModel>;
|
|
505
|
+
in?: $Enums.TerminationStatus[];
|
|
506
|
+
notIn?: $Enums.TerminationStatus[];
|
|
507
|
+
not?: Prisma.NestedEnumTerminationStatusWithAggregatesFilter<$PrismaModel> | $Enums.TerminationStatus;
|
|
508
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
509
|
+
_min?: Prisma.NestedEnumTerminationStatusFilter<$PrismaModel>;
|
|
510
|
+
_max?: Prisma.NestedEnumTerminationStatusFilter<$PrismaModel>;
|
|
511
|
+
};
|
|
512
|
+
export type JsonWithAggregatesFilter<$PrismaModel = never> = Prisma.PatchUndefined<Prisma.Either<Required<JsonWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonWithAggregatesFilterBase<$PrismaModel>>, 'path'>>, Required<JsonWithAggregatesFilterBase<$PrismaModel>>> | Prisma.OptionalFlat<Omit<Required<JsonWithAggregatesFilterBase<$PrismaModel>>, 'path'>>;
|
|
513
|
+
export type JsonWithAggregatesFilterBase<$PrismaModel = never> = {
|
|
304
514
|
equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter;
|
|
305
515
|
path?: string;
|
|
306
516
|
mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel>;
|
|
@@ -315,9 +525,39 @@ export type JsonNullableWithAggregatesFilterBase<$PrismaModel = never> = {
|
|
|
315
525
|
gt?: runtime.InputJsonValue;
|
|
316
526
|
gte?: runtime.InputJsonValue;
|
|
317
527
|
not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter;
|
|
318
|
-
_count?: Prisma.
|
|
319
|
-
_min?: Prisma.
|
|
320
|
-
_max?: Prisma.
|
|
528
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
529
|
+
_min?: Prisma.NestedJsonFilter<$PrismaModel>;
|
|
530
|
+
_max?: Prisma.NestedJsonFilter<$PrismaModel>;
|
|
531
|
+
};
|
|
532
|
+
export type EnumRefundStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
533
|
+
equals?: $Enums.RefundStatus | Prisma.EnumRefundStatusFieldRefInput<$PrismaModel>;
|
|
534
|
+
in?: $Enums.RefundStatus[];
|
|
535
|
+
notIn?: $Enums.RefundStatus[];
|
|
536
|
+
not?: Prisma.NestedEnumRefundStatusWithAggregatesFilter<$PrismaModel> | $Enums.RefundStatus;
|
|
537
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
538
|
+
_min?: Prisma.NestedEnumRefundStatusFilter<$PrismaModel>;
|
|
539
|
+
_max?: Prisma.NestedEnumRefundStatusFilter<$PrismaModel>;
|
|
540
|
+
};
|
|
541
|
+
export type EnumPrequalificationStatusFilter<$PrismaModel = never> = {
|
|
542
|
+
equals?: $Enums.PrequalificationStatus | Prisma.EnumPrequalificationStatusFieldRefInput<$PrismaModel>;
|
|
543
|
+
in?: $Enums.PrequalificationStatus[];
|
|
544
|
+
notIn?: $Enums.PrequalificationStatus[];
|
|
545
|
+
not?: Prisma.NestedEnumPrequalificationStatusFilter<$PrismaModel> | $Enums.PrequalificationStatus;
|
|
546
|
+
};
|
|
547
|
+
export type EnumPrequalificationStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
548
|
+
equals?: $Enums.PrequalificationStatus | Prisma.EnumPrequalificationStatusFieldRefInput<$PrismaModel>;
|
|
549
|
+
in?: $Enums.PrequalificationStatus[];
|
|
550
|
+
notIn?: $Enums.PrequalificationStatus[];
|
|
551
|
+
not?: Prisma.NestedEnumPrequalificationStatusWithAggregatesFilter<$PrismaModel> | $Enums.PrequalificationStatus;
|
|
552
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
553
|
+
_min?: Prisma.NestedEnumPrequalificationStatusFilter<$PrismaModel>;
|
|
554
|
+
_max?: Prisma.NestedEnumPrequalificationStatusFilter<$PrismaModel>;
|
|
555
|
+
};
|
|
556
|
+
export type EnumPaymentMethodChangeStatusFilter<$PrismaModel = never> = {
|
|
557
|
+
equals?: $Enums.PaymentMethodChangeStatus | Prisma.EnumPaymentMethodChangeStatusFieldRefInput<$PrismaModel>;
|
|
558
|
+
in?: $Enums.PaymentMethodChangeStatus[];
|
|
559
|
+
notIn?: $Enums.PaymentMethodChangeStatus[];
|
|
560
|
+
not?: Prisma.NestedEnumPaymentMethodChangeStatusFilter<$PrismaModel> | $Enums.PaymentMethodChangeStatus;
|
|
321
561
|
};
|
|
322
562
|
export type EnumPaymentMethodChangeStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
323
563
|
equals?: $Enums.PaymentMethodChangeStatus | Prisma.EnumPaymentMethodChangeStatusFieldRefInput<$PrismaModel>;
|
|
@@ -562,14 +802,68 @@ export type NestedIntNullableWithAggregatesFilter<$PrismaModel = never> = {
|
|
|
562
802
|
_min?: Prisma.NestedIntNullableFilter<$PrismaModel>;
|
|
563
803
|
_max?: Prisma.NestedIntNullableFilter<$PrismaModel>;
|
|
564
804
|
};
|
|
565
|
-
export type
|
|
566
|
-
equals?: $Enums.
|
|
567
|
-
in?: $Enums.
|
|
568
|
-
notIn?: $Enums.
|
|
569
|
-
not?: Prisma.
|
|
805
|
+
export type NestedEnumPaymentFrequencyFilter<$PrismaModel = never> = {
|
|
806
|
+
equals?: $Enums.PaymentFrequency | Prisma.EnumPaymentFrequencyFieldRefInput<$PrismaModel>;
|
|
807
|
+
in?: $Enums.PaymentFrequency[];
|
|
808
|
+
notIn?: $Enums.PaymentFrequency[];
|
|
809
|
+
not?: Prisma.NestedEnumPaymentFrequencyFilter<$PrismaModel> | $Enums.PaymentFrequency;
|
|
570
810
|
};
|
|
571
|
-
export type
|
|
572
|
-
|
|
811
|
+
export type NestedEnumPaymentFrequencyWithAggregatesFilter<$PrismaModel = never> = {
|
|
812
|
+
equals?: $Enums.PaymentFrequency | Prisma.EnumPaymentFrequencyFieldRefInput<$PrismaModel>;
|
|
813
|
+
in?: $Enums.PaymentFrequency[];
|
|
814
|
+
notIn?: $Enums.PaymentFrequency[];
|
|
815
|
+
not?: Prisma.NestedEnumPaymentFrequencyWithAggregatesFilter<$PrismaModel> | $Enums.PaymentFrequency;
|
|
816
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
817
|
+
_min?: Prisma.NestedEnumPaymentFrequencyFilter<$PrismaModel>;
|
|
818
|
+
_max?: Prisma.NestedEnumPaymentFrequencyFilter<$PrismaModel>;
|
|
819
|
+
};
|
|
820
|
+
export type NestedEnumPhaseCategoryFilter<$PrismaModel = never> = {
|
|
821
|
+
equals?: $Enums.PhaseCategory | Prisma.EnumPhaseCategoryFieldRefInput<$PrismaModel>;
|
|
822
|
+
in?: $Enums.PhaseCategory[];
|
|
823
|
+
notIn?: $Enums.PhaseCategory[];
|
|
824
|
+
not?: Prisma.NestedEnumPhaseCategoryFilter<$PrismaModel> | $Enums.PhaseCategory;
|
|
825
|
+
};
|
|
826
|
+
export type NestedEnumPhaseTypeFilter<$PrismaModel = never> = {
|
|
827
|
+
equals?: $Enums.PhaseType | Prisma.EnumPhaseTypeFieldRefInput<$PrismaModel>;
|
|
828
|
+
in?: $Enums.PhaseType[];
|
|
829
|
+
notIn?: $Enums.PhaseType[];
|
|
830
|
+
not?: Prisma.NestedEnumPhaseTypeFilter<$PrismaModel> | $Enums.PhaseType;
|
|
831
|
+
};
|
|
832
|
+
export type NestedEnumCompletionCriterionNullableFilter<$PrismaModel = never> = {
|
|
833
|
+
equals?: $Enums.CompletionCriterion | Prisma.EnumCompletionCriterionFieldRefInput<$PrismaModel> | null;
|
|
834
|
+
in?: $Enums.CompletionCriterion[] | null;
|
|
835
|
+
notIn?: $Enums.CompletionCriterion[] | null;
|
|
836
|
+
not?: Prisma.NestedEnumCompletionCriterionNullableFilter<$PrismaModel> | $Enums.CompletionCriterion | null;
|
|
837
|
+
};
|
|
838
|
+
export type NestedEnumPhaseCategoryWithAggregatesFilter<$PrismaModel = never> = {
|
|
839
|
+
equals?: $Enums.PhaseCategory | Prisma.EnumPhaseCategoryFieldRefInput<$PrismaModel>;
|
|
840
|
+
in?: $Enums.PhaseCategory[];
|
|
841
|
+
notIn?: $Enums.PhaseCategory[];
|
|
842
|
+
not?: Prisma.NestedEnumPhaseCategoryWithAggregatesFilter<$PrismaModel> | $Enums.PhaseCategory;
|
|
843
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
844
|
+
_min?: Prisma.NestedEnumPhaseCategoryFilter<$PrismaModel>;
|
|
845
|
+
_max?: Prisma.NestedEnumPhaseCategoryFilter<$PrismaModel>;
|
|
846
|
+
};
|
|
847
|
+
export type NestedEnumPhaseTypeWithAggregatesFilter<$PrismaModel = never> = {
|
|
848
|
+
equals?: $Enums.PhaseType | Prisma.EnumPhaseTypeFieldRefInput<$PrismaModel>;
|
|
849
|
+
in?: $Enums.PhaseType[];
|
|
850
|
+
notIn?: $Enums.PhaseType[];
|
|
851
|
+
not?: Prisma.NestedEnumPhaseTypeWithAggregatesFilter<$PrismaModel> | $Enums.PhaseType;
|
|
852
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
853
|
+
_min?: Prisma.NestedEnumPhaseTypeFilter<$PrismaModel>;
|
|
854
|
+
_max?: Prisma.NestedEnumPhaseTypeFilter<$PrismaModel>;
|
|
855
|
+
};
|
|
856
|
+
export type NestedEnumCompletionCriterionNullableWithAggregatesFilter<$PrismaModel = never> = {
|
|
857
|
+
equals?: $Enums.CompletionCriterion | Prisma.EnumCompletionCriterionFieldRefInput<$PrismaModel> | null;
|
|
858
|
+
in?: $Enums.CompletionCriterion[] | null;
|
|
859
|
+
notIn?: $Enums.CompletionCriterion[] | null;
|
|
860
|
+
not?: Prisma.NestedEnumCompletionCriterionNullableWithAggregatesFilter<$PrismaModel> | $Enums.CompletionCriterion | null;
|
|
861
|
+
_count?: Prisma.NestedIntNullableFilter<$PrismaModel>;
|
|
862
|
+
_min?: Prisma.NestedEnumCompletionCriterionNullableFilter<$PrismaModel>;
|
|
863
|
+
_max?: Prisma.NestedEnumCompletionCriterionNullableFilter<$PrismaModel>;
|
|
864
|
+
};
|
|
865
|
+
export type NestedJsonNullableFilter<$PrismaModel = never> = Prisma.PatchUndefined<Prisma.Either<Required<NestedJsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<NestedJsonNullableFilterBase<$PrismaModel>>, 'path'>>, Required<NestedJsonNullableFilterBase<$PrismaModel>>> | Prisma.OptionalFlat<Omit<Required<NestedJsonNullableFilterBase<$PrismaModel>>, 'path'>>;
|
|
866
|
+
export type NestedJsonNullableFilterBase<$PrismaModel = never> = {
|
|
573
867
|
equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter;
|
|
574
868
|
path?: string;
|
|
575
869
|
mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel>;
|
|
@@ -585,23 +879,179 @@ export type NestedJsonFilterBase<$PrismaModel = never> = {
|
|
|
585
879
|
gte?: runtime.InputJsonValue;
|
|
586
880
|
not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter;
|
|
587
881
|
};
|
|
588
|
-
export type
|
|
589
|
-
equals?: $Enums.
|
|
590
|
-
in?: $Enums.
|
|
591
|
-
notIn?: $Enums.
|
|
592
|
-
not?: Prisma.
|
|
882
|
+
export type NestedEnumStepTypeFilter<$PrismaModel = never> = {
|
|
883
|
+
equals?: $Enums.StepType | Prisma.EnumStepTypeFieldRefInput<$PrismaModel>;
|
|
884
|
+
in?: $Enums.StepType[];
|
|
885
|
+
notIn?: $Enums.StepType[];
|
|
886
|
+
not?: Prisma.NestedEnumStepTypeFilter<$PrismaModel> | $Enums.StepType;
|
|
887
|
+
};
|
|
888
|
+
export type NestedEnumStepTypeWithAggregatesFilter<$PrismaModel = never> = {
|
|
889
|
+
equals?: $Enums.StepType | Prisma.EnumStepTypeFieldRefInput<$PrismaModel>;
|
|
890
|
+
in?: $Enums.StepType[];
|
|
891
|
+
notIn?: $Enums.StepType[];
|
|
892
|
+
not?: Prisma.NestedEnumStepTypeWithAggregatesFilter<$PrismaModel> | $Enums.StepType;
|
|
593
893
|
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
594
|
-
_min?: Prisma.
|
|
595
|
-
_max?: Prisma.
|
|
894
|
+
_min?: Prisma.NestedEnumStepTypeFilter<$PrismaModel>;
|
|
895
|
+
_max?: Prisma.NestedEnumStepTypeFilter<$PrismaModel>;
|
|
596
896
|
};
|
|
597
|
-
export type
|
|
598
|
-
equals?: $Enums.
|
|
599
|
-
in?: $Enums.
|
|
600
|
-
notIn?: $Enums.
|
|
601
|
-
not?: Prisma.
|
|
897
|
+
export type NestedEnumContractStatusFilter<$PrismaModel = never> = {
|
|
898
|
+
equals?: $Enums.ContractStatus | Prisma.EnumContractStatusFieldRefInput<$PrismaModel>;
|
|
899
|
+
in?: $Enums.ContractStatus[];
|
|
900
|
+
notIn?: $Enums.ContractStatus[];
|
|
901
|
+
not?: Prisma.NestedEnumContractStatusFilter<$PrismaModel> | $Enums.ContractStatus;
|
|
602
902
|
};
|
|
603
|
-
export type
|
|
604
|
-
|
|
903
|
+
export type NestedEnumContractStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
904
|
+
equals?: $Enums.ContractStatus | Prisma.EnumContractStatusFieldRefInput<$PrismaModel>;
|
|
905
|
+
in?: $Enums.ContractStatus[];
|
|
906
|
+
notIn?: $Enums.ContractStatus[];
|
|
907
|
+
not?: Prisma.NestedEnumContractStatusWithAggregatesFilter<$PrismaModel> | $Enums.ContractStatus;
|
|
908
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
909
|
+
_min?: Prisma.NestedEnumContractStatusFilter<$PrismaModel>;
|
|
910
|
+
_max?: Prisma.NestedEnumContractStatusFilter<$PrismaModel>;
|
|
911
|
+
};
|
|
912
|
+
export type NestedEnumPhaseStatusFilter<$PrismaModel = never> = {
|
|
913
|
+
equals?: $Enums.PhaseStatus | Prisma.EnumPhaseStatusFieldRefInput<$PrismaModel>;
|
|
914
|
+
in?: $Enums.PhaseStatus[];
|
|
915
|
+
notIn?: $Enums.PhaseStatus[];
|
|
916
|
+
not?: Prisma.NestedEnumPhaseStatusFilter<$PrismaModel> | $Enums.PhaseStatus;
|
|
917
|
+
};
|
|
918
|
+
export type NestedEnumPhaseStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
919
|
+
equals?: $Enums.PhaseStatus | Prisma.EnumPhaseStatusFieldRefInput<$PrismaModel>;
|
|
920
|
+
in?: $Enums.PhaseStatus[];
|
|
921
|
+
notIn?: $Enums.PhaseStatus[];
|
|
922
|
+
not?: Prisma.NestedEnumPhaseStatusWithAggregatesFilter<$PrismaModel> | $Enums.PhaseStatus;
|
|
923
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
924
|
+
_min?: Prisma.NestedEnumPhaseStatusFilter<$PrismaModel>;
|
|
925
|
+
_max?: Prisma.NestedEnumPhaseStatusFilter<$PrismaModel>;
|
|
926
|
+
};
|
|
927
|
+
export type NestedEnumStepStatusFilter<$PrismaModel = never> = {
|
|
928
|
+
equals?: $Enums.StepStatus | Prisma.EnumStepStatusFieldRefInput<$PrismaModel>;
|
|
929
|
+
in?: $Enums.StepStatus[];
|
|
930
|
+
notIn?: $Enums.StepStatus[];
|
|
931
|
+
not?: Prisma.NestedEnumStepStatusFilter<$PrismaModel> | $Enums.StepStatus;
|
|
932
|
+
};
|
|
933
|
+
export type NestedEnumStepStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
934
|
+
equals?: $Enums.StepStatus | Prisma.EnumStepStatusFieldRefInput<$PrismaModel>;
|
|
935
|
+
in?: $Enums.StepStatus[];
|
|
936
|
+
notIn?: $Enums.StepStatus[];
|
|
937
|
+
not?: Prisma.NestedEnumStepStatusWithAggregatesFilter<$PrismaModel> | $Enums.StepStatus;
|
|
938
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
939
|
+
_min?: Prisma.NestedEnumStepStatusFilter<$PrismaModel>;
|
|
940
|
+
_max?: Prisma.NestedEnumStepStatusFilter<$PrismaModel>;
|
|
941
|
+
};
|
|
942
|
+
export type NestedEnumApprovalDecisionFilter<$PrismaModel = never> = {
|
|
943
|
+
equals?: $Enums.ApprovalDecision | Prisma.EnumApprovalDecisionFieldRefInput<$PrismaModel>;
|
|
944
|
+
in?: $Enums.ApprovalDecision[];
|
|
945
|
+
notIn?: $Enums.ApprovalDecision[];
|
|
946
|
+
not?: Prisma.NestedEnumApprovalDecisionFilter<$PrismaModel> | $Enums.ApprovalDecision;
|
|
947
|
+
};
|
|
948
|
+
export type NestedEnumApprovalDecisionWithAggregatesFilter<$PrismaModel = never> = {
|
|
949
|
+
equals?: $Enums.ApprovalDecision | Prisma.EnumApprovalDecisionFieldRefInput<$PrismaModel>;
|
|
950
|
+
in?: $Enums.ApprovalDecision[];
|
|
951
|
+
notIn?: $Enums.ApprovalDecision[];
|
|
952
|
+
not?: Prisma.NestedEnumApprovalDecisionWithAggregatesFilter<$PrismaModel> | $Enums.ApprovalDecision;
|
|
953
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
954
|
+
_min?: Prisma.NestedEnumApprovalDecisionFilter<$PrismaModel>;
|
|
955
|
+
_max?: Prisma.NestedEnumApprovalDecisionFilter<$PrismaModel>;
|
|
956
|
+
};
|
|
957
|
+
export type NestedEnumInstallmentStatusFilter<$PrismaModel = never> = {
|
|
958
|
+
equals?: $Enums.InstallmentStatus | Prisma.EnumInstallmentStatusFieldRefInput<$PrismaModel>;
|
|
959
|
+
in?: $Enums.InstallmentStatus[];
|
|
960
|
+
notIn?: $Enums.InstallmentStatus[];
|
|
961
|
+
not?: Prisma.NestedEnumInstallmentStatusFilter<$PrismaModel> | $Enums.InstallmentStatus;
|
|
962
|
+
};
|
|
963
|
+
export type NestedEnumInstallmentStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
964
|
+
equals?: $Enums.InstallmentStatus | Prisma.EnumInstallmentStatusFieldRefInput<$PrismaModel>;
|
|
965
|
+
in?: $Enums.InstallmentStatus[];
|
|
966
|
+
notIn?: $Enums.InstallmentStatus[];
|
|
967
|
+
not?: Prisma.NestedEnumInstallmentStatusWithAggregatesFilter<$PrismaModel> | $Enums.InstallmentStatus;
|
|
968
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
969
|
+
_min?: Prisma.NestedEnumInstallmentStatusFilter<$PrismaModel>;
|
|
970
|
+
_max?: Prisma.NestedEnumInstallmentStatusFilter<$PrismaModel>;
|
|
971
|
+
};
|
|
972
|
+
export type NestedEnumPaymentStatusFilter<$PrismaModel = never> = {
|
|
973
|
+
equals?: $Enums.PaymentStatus | Prisma.EnumPaymentStatusFieldRefInput<$PrismaModel>;
|
|
974
|
+
in?: $Enums.PaymentStatus[];
|
|
975
|
+
notIn?: $Enums.PaymentStatus[];
|
|
976
|
+
not?: Prisma.NestedEnumPaymentStatusFilter<$PrismaModel> | $Enums.PaymentStatus;
|
|
977
|
+
};
|
|
978
|
+
export type NestedEnumPaymentStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
979
|
+
equals?: $Enums.PaymentStatus | Prisma.EnumPaymentStatusFieldRefInput<$PrismaModel>;
|
|
980
|
+
in?: $Enums.PaymentStatus[];
|
|
981
|
+
notIn?: $Enums.PaymentStatus[];
|
|
982
|
+
not?: Prisma.NestedEnumPaymentStatusWithAggregatesFilter<$PrismaModel> | $Enums.PaymentStatus;
|
|
983
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
984
|
+
_min?: Prisma.NestedEnumPaymentStatusFilter<$PrismaModel>;
|
|
985
|
+
_max?: Prisma.NestedEnumPaymentStatusFilter<$PrismaModel>;
|
|
986
|
+
};
|
|
987
|
+
export type NestedEnumDocumentStatusFilter<$PrismaModel = never> = {
|
|
988
|
+
equals?: $Enums.DocumentStatus | Prisma.EnumDocumentStatusFieldRefInput<$PrismaModel>;
|
|
989
|
+
in?: $Enums.DocumentStatus[];
|
|
990
|
+
notIn?: $Enums.DocumentStatus[];
|
|
991
|
+
not?: Prisma.NestedEnumDocumentStatusFilter<$PrismaModel> | $Enums.DocumentStatus;
|
|
992
|
+
};
|
|
993
|
+
export type NestedEnumDocumentStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
994
|
+
equals?: $Enums.DocumentStatus | Prisma.EnumDocumentStatusFieldRefInput<$PrismaModel>;
|
|
995
|
+
in?: $Enums.DocumentStatus[];
|
|
996
|
+
notIn?: $Enums.DocumentStatus[];
|
|
997
|
+
not?: Prisma.NestedEnumDocumentStatusWithAggregatesFilter<$PrismaModel> | $Enums.DocumentStatus;
|
|
998
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
999
|
+
_min?: Prisma.NestedEnumDocumentStatusFilter<$PrismaModel>;
|
|
1000
|
+
_max?: Prisma.NestedEnumDocumentStatusFilter<$PrismaModel>;
|
|
1001
|
+
};
|
|
1002
|
+
export type NestedEnumTerminationInitiatorFilter<$PrismaModel = never> = {
|
|
1003
|
+
equals?: $Enums.TerminationInitiator | Prisma.EnumTerminationInitiatorFieldRefInput<$PrismaModel>;
|
|
1004
|
+
in?: $Enums.TerminationInitiator[];
|
|
1005
|
+
notIn?: $Enums.TerminationInitiator[];
|
|
1006
|
+
not?: Prisma.NestedEnumTerminationInitiatorFilter<$PrismaModel> | $Enums.TerminationInitiator;
|
|
1007
|
+
};
|
|
1008
|
+
export type NestedEnumTerminationTypeFilter<$PrismaModel = never> = {
|
|
1009
|
+
equals?: $Enums.TerminationType | Prisma.EnumTerminationTypeFieldRefInput<$PrismaModel>;
|
|
1010
|
+
in?: $Enums.TerminationType[];
|
|
1011
|
+
notIn?: $Enums.TerminationType[];
|
|
1012
|
+
not?: Prisma.NestedEnumTerminationTypeFilter<$PrismaModel> | $Enums.TerminationType;
|
|
1013
|
+
};
|
|
1014
|
+
export type NestedEnumTerminationStatusFilter<$PrismaModel = never> = {
|
|
1015
|
+
equals?: $Enums.TerminationStatus | Prisma.EnumTerminationStatusFieldRefInput<$PrismaModel>;
|
|
1016
|
+
in?: $Enums.TerminationStatus[];
|
|
1017
|
+
notIn?: $Enums.TerminationStatus[];
|
|
1018
|
+
not?: Prisma.NestedEnumTerminationStatusFilter<$PrismaModel> | $Enums.TerminationStatus;
|
|
1019
|
+
};
|
|
1020
|
+
export type NestedEnumRefundStatusFilter<$PrismaModel = never> = {
|
|
1021
|
+
equals?: $Enums.RefundStatus | Prisma.EnumRefundStatusFieldRefInput<$PrismaModel>;
|
|
1022
|
+
in?: $Enums.RefundStatus[];
|
|
1023
|
+
notIn?: $Enums.RefundStatus[];
|
|
1024
|
+
not?: Prisma.NestedEnumRefundStatusFilter<$PrismaModel> | $Enums.RefundStatus;
|
|
1025
|
+
};
|
|
1026
|
+
export type NestedEnumTerminationInitiatorWithAggregatesFilter<$PrismaModel = never> = {
|
|
1027
|
+
equals?: $Enums.TerminationInitiator | Prisma.EnumTerminationInitiatorFieldRefInput<$PrismaModel>;
|
|
1028
|
+
in?: $Enums.TerminationInitiator[];
|
|
1029
|
+
notIn?: $Enums.TerminationInitiator[];
|
|
1030
|
+
not?: Prisma.NestedEnumTerminationInitiatorWithAggregatesFilter<$PrismaModel> | $Enums.TerminationInitiator;
|
|
1031
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
1032
|
+
_min?: Prisma.NestedEnumTerminationInitiatorFilter<$PrismaModel>;
|
|
1033
|
+
_max?: Prisma.NestedEnumTerminationInitiatorFilter<$PrismaModel>;
|
|
1034
|
+
};
|
|
1035
|
+
export type NestedEnumTerminationTypeWithAggregatesFilter<$PrismaModel = never> = {
|
|
1036
|
+
equals?: $Enums.TerminationType | Prisma.EnumTerminationTypeFieldRefInput<$PrismaModel>;
|
|
1037
|
+
in?: $Enums.TerminationType[];
|
|
1038
|
+
notIn?: $Enums.TerminationType[];
|
|
1039
|
+
not?: Prisma.NestedEnumTerminationTypeWithAggregatesFilter<$PrismaModel> | $Enums.TerminationType;
|
|
1040
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
1041
|
+
_min?: Prisma.NestedEnumTerminationTypeFilter<$PrismaModel>;
|
|
1042
|
+
_max?: Prisma.NestedEnumTerminationTypeFilter<$PrismaModel>;
|
|
1043
|
+
};
|
|
1044
|
+
export type NestedEnumTerminationStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
1045
|
+
equals?: $Enums.TerminationStatus | Prisma.EnumTerminationStatusFieldRefInput<$PrismaModel>;
|
|
1046
|
+
in?: $Enums.TerminationStatus[];
|
|
1047
|
+
notIn?: $Enums.TerminationStatus[];
|
|
1048
|
+
not?: Prisma.NestedEnumTerminationStatusWithAggregatesFilter<$PrismaModel> | $Enums.TerminationStatus;
|
|
1049
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
1050
|
+
_min?: Prisma.NestedEnumTerminationStatusFilter<$PrismaModel>;
|
|
1051
|
+
_max?: Prisma.NestedEnumTerminationStatusFilter<$PrismaModel>;
|
|
1052
|
+
};
|
|
1053
|
+
export type NestedJsonFilter<$PrismaModel = never> = Prisma.PatchUndefined<Prisma.Either<Required<NestedJsonFilterBase<$PrismaModel>>, Exclude<keyof Required<NestedJsonFilterBase<$PrismaModel>>, 'path'>>, Required<NestedJsonFilterBase<$PrismaModel>>> | Prisma.OptionalFlat<Omit<Required<NestedJsonFilterBase<$PrismaModel>>, 'path'>>;
|
|
1054
|
+
export type NestedJsonFilterBase<$PrismaModel = never> = {
|
|
605
1055
|
equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter;
|
|
606
1056
|
path?: string;
|
|
607
1057
|
mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel>;
|
|
@@ -617,6 +1067,36 @@ export type NestedJsonNullableFilterBase<$PrismaModel = never> = {
|
|
|
617
1067
|
gte?: runtime.InputJsonValue;
|
|
618
1068
|
not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter;
|
|
619
1069
|
};
|
|
1070
|
+
export type NestedEnumRefundStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
1071
|
+
equals?: $Enums.RefundStatus | Prisma.EnumRefundStatusFieldRefInput<$PrismaModel>;
|
|
1072
|
+
in?: $Enums.RefundStatus[];
|
|
1073
|
+
notIn?: $Enums.RefundStatus[];
|
|
1074
|
+
not?: Prisma.NestedEnumRefundStatusWithAggregatesFilter<$PrismaModel> | $Enums.RefundStatus;
|
|
1075
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
1076
|
+
_min?: Prisma.NestedEnumRefundStatusFilter<$PrismaModel>;
|
|
1077
|
+
_max?: Prisma.NestedEnumRefundStatusFilter<$PrismaModel>;
|
|
1078
|
+
};
|
|
1079
|
+
export type NestedEnumPrequalificationStatusFilter<$PrismaModel = never> = {
|
|
1080
|
+
equals?: $Enums.PrequalificationStatus | Prisma.EnumPrequalificationStatusFieldRefInput<$PrismaModel>;
|
|
1081
|
+
in?: $Enums.PrequalificationStatus[];
|
|
1082
|
+
notIn?: $Enums.PrequalificationStatus[];
|
|
1083
|
+
not?: Prisma.NestedEnumPrequalificationStatusFilter<$PrismaModel> | $Enums.PrequalificationStatus;
|
|
1084
|
+
};
|
|
1085
|
+
export type NestedEnumPrequalificationStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
1086
|
+
equals?: $Enums.PrequalificationStatus | Prisma.EnumPrequalificationStatusFieldRefInput<$PrismaModel>;
|
|
1087
|
+
in?: $Enums.PrequalificationStatus[];
|
|
1088
|
+
notIn?: $Enums.PrequalificationStatus[];
|
|
1089
|
+
not?: Prisma.NestedEnumPrequalificationStatusWithAggregatesFilter<$PrismaModel> | $Enums.PrequalificationStatus;
|
|
1090
|
+
_count?: Prisma.NestedIntFilter<$PrismaModel>;
|
|
1091
|
+
_min?: Prisma.NestedEnumPrequalificationStatusFilter<$PrismaModel>;
|
|
1092
|
+
_max?: Prisma.NestedEnumPrequalificationStatusFilter<$PrismaModel>;
|
|
1093
|
+
};
|
|
1094
|
+
export type NestedEnumPaymentMethodChangeStatusFilter<$PrismaModel = never> = {
|
|
1095
|
+
equals?: $Enums.PaymentMethodChangeStatus | Prisma.EnumPaymentMethodChangeStatusFieldRefInput<$PrismaModel>;
|
|
1096
|
+
in?: $Enums.PaymentMethodChangeStatus[];
|
|
1097
|
+
notIn?: $Enums.PaymentMethodChangeStatus[];
|
|
1098
|
+
not?: Prisma.NestedEnumPaymentMethodChangeStatusFilter<$PrismaModel> | $Enums.PaymentMethodChangeStatus;
|
|
1099
|
+
};
|
|
620
1100
|
export type NestedEnumPaymentMethodChangeStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
621
1101
|
equals?: $Enums.PaymentMethodChangeStatus | Prisma.EnumPaymentMethodChangeStatusFieldRefInput<$PrismaModel>;
|
|
622
1102
|
in?: $Enums.PaymentMethodChangeStatus[];
|