@valentine-efagene/qshelter-common 2.0.84 → 2.0.87
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 +25 -0
- package/dist/generated/client/client.d.ts +25 -0
- package/dist/generated/client/commonInputTypes.d.ts +30 -0
- package/dist/generated/client/enums.d.ts +18 -0
- package/dist/generated/client/enums.js +17 -0
- package/dist/generated/client/internal/class.d.ts +55 -0
- package/dist/generated/client/internal/class.js +2 -2
- package/dist/generated/client/internal/prismaNamespace.d.ts +469 -42
- package/dist/generated/client/internal/prismaNamespace.js +118 -40
- package/dist/generated/client/internal/prismaNamespaceBrowser.d.ts +129 -41
- package/dist/generated/client/internal/prismaNamespaceBrowser.js +118 -40
- package/dist/generated/client/models/Contract.d.ts +303 -1574
- package/dist/generated/client/models/ContractInstallment.d.ts +77 -77
- package/dist/generated/client/models/ContractPhase.d.ts +339 -1376
- package/dist/generated/client/models/DocumentationPhase.d.ts +1649 -0
- package/dist/generated/client/models/DocumentationPhase.js +1 -0
- package/dist/generated/client/models/DocumentationStep.d.ts +126 -387
- package/dist/generated/client/models/PaymentMethodPhaseField.d.ts +1378 -0
- package/dist/generated/client/models/PaymentMethodPhaseField.js +1 -0
- package/dist/generated/client/models/PaymentPhase.d.ts +1566 -0
- package/dist/generated/client/models/PaymentPhase.js +1 -0
- package/dist/generated/client/models/PaymentPlan.d.ts +53 -53
- package/dist/generated/client/models/PropertyPaymentMethodPhase.d.ts +171 -0
- package/dist/generated/client/models/PropertyTransferRequest.d.ts +196 -70
- package/dist/generated/client/models/QuestionnaireField.d.ts +1495 -0
- package/dist/generated/client/models/QuestionnaireField.js +1 -0
- package/dist/generated/client/models/QuestionnairePhase.d.ts +1383 -0
- package/dist/generated/client/models/QuestionnairePhase.js +1 -0
- package/dist/generated/client/models.d.ts +5 -0
- package/package.json +1 -1
- package/prisma/migrations/20260109132751_update_transfer_flow/migration.sql +343 -0
- package/prisma/schema.prisma +304 -98
|
@@ -0,0 +1,1649 @@
|
|
|
1
|
+
import type * as runtime from "@prisma/client/runtime/client";
|
|
2
|
+
import type * as $Enums from "../enums.js";
|
|
3
|
+
import type * as Prisma from "../internal/prismaNamespace.js";
|
|
4
|
+
/**
|
|
5
|
+
* Model DocumentationPhase
|
|
6
|
+
*
|
|
7
|
+
*/
|
|
8
|
+
export type DocumentationPhaseModel = runtime.Types.Result.DefaultSelection<Prisma.$DocumentationPhasePayload>;
|
|
9
|
+
export type AggregateDocumentationPhase = {
|
|
10
|
+
_count: DocumentationPhaseCountAggregateOutputType | null;
|
|
11
|
+
_avg: DocumentationPhaseAvgAggregateOutputType | null;
|
|
12
|
+
_sum: DocumentationPhaseSumAggregateOutputType | null;
|
|
13
|
+
_min: DocumentationPhaseMinAggregateOutputType | null;
|
|
14
|
+
_max: DocumentationPhaseMaxAggregateOutputType | null;
|
|
15
|
+
};
|
|
16
|
+
export type DocumentationPhaseAvgAggregateOutputType = {
|
|
17
|
+
approvedDocumentsCount: number | null;
|
|
18
|
+
requiredDocumentsCount: number | null;
|
|
19
|
+
completedStepsCount: number | null;
|
|
20
|
+
totalStepsCount: number | null;
|
|
21
|
+
minimumCompletionPercentage: number | null;
|
|
22
|
+
};
|
|
23
|
+
export type DocumentationPhaseSumAggregateOutputType = {
|
|
24
|
+
approvedDocumentsCount: number | null;
|
|
25
|
+
requiredDocumentsCount: number | null;
|
|
26
|
+
completedStepsCount: number | null;
|
|
27
|
+
totalStepsCount: number | null;
|
|
28
|
+
minimumCompletionPercentage: number | null;
|
|
29
|
+
};
|
|
30
|
+
export type DocumentationPhaseMinAggregateOutputType = {
|
|
31
|
+
id: string | null;
|
|
32
|
+
phaseId: string | null;
|
|
33
|
+
currentStepId: string | null;
|
|
34
|
+
approvedDocumentsCount: number | null;
|
|
35
|
+
requiredDocumentsCount: number | null;
|
|
36
|
+
completedStepsCount: number | null;
|
|
37
|
+
totalStepsCount: number | null;
|
|
38
|
+
minimumCompletionPercentage: number | null;
|
|
39
|
+
completionCriterion: $Enums.CompletionCriterion | null;
|
|
40
|
+
createdAt: Date | null;
|
|
41
|
+
updatedAt: Date | null;
|
|
42
|
+
};
|
|
43
|
+
export type DocumentationPhaseMaxAggregateOutputType = {
|
|
44
|
+
id: string | null;
|
|
45
|
+
phaseId: string | null;
|
|
46
|
+
currentStepId: string | null;
|
|
47
|
+
approvedDocumentsCount: number | null;
|
|
48
|
+
requiredDocumentsCount: number | null;
|
|
49
|
+
completedStepsCount: number | null;
|
|
50
|
+
totalStepsCount: number | null;
|
|
51
|
+
minimumCompletionPercentage: number | null;
|
|
52
|
+
completionCriterion: $Enums.CompletionCriterion | null;
|
|
53
|
+
createdAt: Date | null;
|
|
54
|
+
updatedAt: Date | null;
|
|
55
|
+
};
|
|
56
|
+
export type DocumentationPhaseCountAggregateOutputType = {
|
|
57
|
+
id: number;
|
|
58
|
+
phaseId: number;
|
|
59
|
+
currentStepId: number;
|
|
60
|
+
approvedDocumentsCount: number;
|
|
61
|
+
requiredDocumentsCount: number;
|
|
62
|
+
completedStepsCount: number;
|
|
63
|
+
totalStepsCount: number;
|
|
64
|
+
minimumCompletionPercentage: number;
|
|
65
|
+
completionCriterion: number;
|
|
66
|
+
stepDefinitionsSnapshot: number;
|
|
67
|
+
requiredDocumentSnapshot: number;
|
|
68
|
+
createdAt: number;
|
|
69
|
+
updatedAt: number;
|
|
70
|
+
_all: number;
|
|
71
|
+
};
|
|
72
|
+
export type DocumentationPhaseAvgAggregateInputType = {
|
|
73
|
+
approvedDocumentsCount?: true;
|
|
74
|
+
requiredDocumentsCount?: true;
|
|
75
|
+
completedStepsCount?: true;
|
|
76
|
+
totalStepsCount?: true;
|
|
77
|
+
minimumCompletionPercentage?: true;
|
|
78
|
+
};
|
|
79
|
+
export type DocumentationPhaseSumAggregateInputType = {
|
|
80
|
+
approvedDocumentsCount?: true;
|
|
81
|
+
requiredDocumentsCount?: true;
|
|
82
|
+
completedStepsCount?: true;
|
|
83
|
+
totalStepsCount?: true;
|
|
84
|
+
minimumCompletionPercentage?: true;
|
|
85
|
+
};
|
|
86
|
+
export type DocumentationPhaseMinAggregateInputType = {
|
|
87
|
+
id?: true;
|
|
88
|
+
phaseId?: true;
|
|
89
|
+
currentStepId?: true;
|
|
90
|
+
approvedDocumentsCount?: true;
|
|
91
|
+
requiredDocumentsCount?: true;
|
|
92
|
+
completedStepsCount?: true;
|
|
93
|
+
totalStepsCount?: true;
|
|
94
|
+
minimumCompletionPercentage?: true;
|
|
95
|
+
completionCriterion?: true;
|
|
96
|
+
createdAt?: true;
|
|
97
|
+
updatedAt?: true;
|
|
98
|
+
};
|
|
99
|
+
export type DocumentationPhaseMaxAggregateInputType = {
|
|
100
|
+
id?: true;
|
|
101
|
+
phaseId?: true;
|
|
102
|
+
currentStepId?: true;
|
|
103
|
+
approvedDocumentsCount?: true;
|
|
104
|
+
requiredDocumentsCount?: true;
|
|
105
|
+
completedStepsCount?: true;
|
|
106
|
+
totalStepsCount?: true;
|
|
107
|
+
minimumCompletionPercentage?: true;
|
|
108
|
+
completionCriterion?: true;
|
|
109
|
+
createdAt?: true;
|
|
110
|
+
updatedAt?: true;
|
|
111
|
+
};
|
|
112
|
+
export type DocumentationPhaseCountAggregateInputType = {
|
|
113
|
+
id?: true;
|
|
114
|
+
phaseId?: true;
|
|
115
|
+
currentStepId?: true;
|
|
116
|
+
approvedDocumentsCount?: true;
|
|
117
|
+
requiredDocumentsCount?: true;
|
|
118
|
+
completedStepsCount?: true;
|
|
119
|
+
totalStepsCount?: true;
|
|
120
|
+
minimumCompletionPercentage?: true;
|
|
121
|
+
completionCriterion?: true;
|
|
122
|
+
stepDefinitionsSnapshot?: true;
|
|
123
|
+
requiredDocumentSnapshot?: true;
|
|
124
|
+
createdAt?: true;
|
|
125
|
+
updatedAt?: true;
|
|
126
|
+
_all?: true;
|
|
127
|
+
};
|
|
128
|
+
export type DocumentationPhaseAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
129
|
+
/**
|
|
130
|
+
* Filter which DocumentationPhase to aggregate.
|
|
131
|
+
*/
|
|
132
|
+
where?: Prisma.DocumentationPhaseWhereInput;
|
|
133
|
+
/**
|
|
134
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
135
|
+
*
|
|
136
|
+
* Determine the order of DocumentationPhases to fetch.
|
|
137
|
+
*/
|
|
138
|
+
orderBy?: Prisma.DocumentationPhaseOrderByWithRelationInput | Prisma.DocumentationPhaseOrderByWithRelationInput[];
|
|
139
|
+
/**
|
|
140
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
141
|
+
*
|
|
142
|
+
* Sets the start position
|
|
143
|
+
*/
|
|
144
|
+
cursor?: Prisma.DocumentationPhaseWhereUniqueInput;
|
|
145
|
+
/**
|
|
146
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
147
|
+
*
|
|
148
|
+
* Take `±n` DocumentationPhases from the position of the cursor.
|
|
149
|
+
*/
|
|
150
|
+
take?: number;
|
|
151
|
+
/**
|
|
152
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
153
|
+
*
|
|
154
|
+
* Skip the first `n` DocumentationPhases.
|
|
155
|
+
*/
|
|
156
|
+
skip?: number;
|
|
157
|
+
/**
|
|
158
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
159
|
+
*
|
|
160
|
+
* Count returned DocumentationPhases
|
|
161
|
+
**/
|
|
162
|
+
_count?: true | DocumentationPhaseCountAggregateInputType;
|
|
163
|
+
/**
|
|
164
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
165
|
+
*
|
|
166
|
+
* Select which fields to average
|
|
167
|
+
**/
|
|
168
|
+
_avg?: DocumentationPhaseAvgAggregateInputType;
|
|
169
|
+
/**
|
|
170
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
171
|
+
*
|
|
172
|
+
* Select which fields to sum
|
|
173
|
+
**/
|
|
174
|
+
_sum?: DocumentationPhaseSumAggregateInputType;
|
|
175
|
+
/**
|
|
176
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
177
|
+
*
|
|
178
|
+
* Select which fields to find the minimum value
|
|
179
|
+
**/
|
|
180
|
+
_min?: DocumentationPhaseMinAggregateInputType;
|
|
181
|
+
/**
|
|
182
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
183
|
+
*
|
|
184
|
+
* Select which fields to find the maximum value
|
|
185
|
+
**/
|
|
186
|
+
_max?: DocumentationPhaseMaxAggregateInputType;
|
|
187
|
+
};
|
|
188
|
+
export type GetDocumentationPhaseAggregateType<T extends DocumentationPhaseAggregateArgs> = {
|
|
189
|
+
[P in keyof T & keyof AggregateDocumentationPhase]: P extends '_count' | 'count' ? T[P] extends true ? number : Prisma.GetScalarType<T[P], AggregateDocumentationPhase[P]> : Prisma.GetScalarType<T[P], AggregateDocumentationPhase[P]>;
|
|
190
|
+
};
|
|
191
|
+
export type DocumentationPhaseGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
192
|
+
where?: Prisma.DocumentationPhaseWhereInput;
|
|
193
|
+
orderBy?: Prisma.DocumentationPhaseOrderByWithAggregationInput | Prisma.DocumentationPhaseOrderByWithAggregationInput[];
|
|
194
|
+
by: Prisma.DocumentationPhaseScalarFieldEnum[] | Prisma.DocumentationPhaseScalarFieldEnum;
|
|
195
|
+
having?: Prisma.DocumentationPhaseScalarWhereWithAggregatesInput;
|
|
196
|
+
take?: number;
|
|
197
|
+
skip?: number;
|
|
198
|
+
_count?: DocumentationPhaseCountAggregateInputType | true;
|
|
199
|
+
_avg?: DocumentationPhaseAvgAggregateInputType;
|
|
200
|
+
_sum?: DocumentationPhaseSumAggregateInputType;
|
|
201
|
+
_min?: DocumentationPhaseMinAggregateInputType;
|
|
202
|
+
_max?: DocumentationPhaseMaxAggregateInputType;
|
|
203
|
+
};
|
|
204
|
+
export type DocumentationPhaseGroupByOutputType = {
|
|
205
|
+
id: string;
|
|
206
|
+
phaseId: string;
|
|
207
|
+
currentStepId: string | null;
|
|
208
|
+
approvedDocumentsCount: number;
|
|
209
|
+
requiredDocumentsCount: number;
|
|
210
|
+
completedStepsCount: number;
|
|
211
|
+
totalStepsCount: number;
|
|
212
|
+
minimumCompletionPercentage: number | null;
|
|
213
|
+
completionCriterion: $Enums.CompletionCriterion | null;
|
|
214
|
+
stepDefinitionsSnapshot: runtime.JsonValue | null;
|
|
215
|
+
requiredDocumentSnapshot: runtime.JsonValue | null;
|
|
216
|
+
createdAt: Date;
|
|
217
|
+
updatedAt: Date;
|
|
218
|
+
_count: DocumentationPhaseCountAggregateOutputType | null;
|
|
219
|
+
_avg: DocumentationPhaseAvgAggregateOutputType | null;
|
|
220
|
+
_sum: DocumentationPhaseSumAggregateOutputType | null;
|
|
221
|
+
_min: DocumentationPhaseMinAggregateOutputType | null;
|
|
222
|
+
_max: DocumentationPhaseMaxAggregateOutputType | null;
|
|
223
|
+
};
|
|
224
|
+
type GetDocumentationPhaseGroupByPayload<T extends DocumentationPhaseGroupByArgs> = Prisma.PrismaPromise<Array<Prisma.PickEnumerable<DocumentationPhaseGroupByOutputType, T['by']> & {
|
|
225
|
+
[P in ((keyof T) & (keyof DocumentationPhaseGroupByOutputType))]: P extends '_count' ? T[P] extends boolean ? number : Prisma.GetScalarType<T[P], DocumentationPhaseGroupByOutputType[P]> : Prisma.GetScalarType<T[P], DocumentationPhaseGroupByOutputType[P]>;
|
|
226
|
+
}>>;
|
|
227
|
+
export type DocumentationPhaseWhereInput = {
|
|
228
|
+
AND?: Prisma.DocumentationPhaseWhereInput | Prisma.DocumentationPhaseWhereInput[];
|
|
229
|
+
OR?: Prisma.DocumentationPhaseWhereInput[];
|
|
230
|
+
NOT?: Prisma.DocumentationPhaseWhereInput | Prisma.DocumentationPhaseWhereInput[];
|
|
231
|
+
id?: Prisma.StringFilter<"DocumentationPhase"> | string;
|
|
232
|
+
phaseId?: Prisma.StringFilter<"DocumentationPhase"> | string;
|
|
233
|
+
currentStepId?: Prisma.StringNullableFilter<"DocumentationPhase"> | string | null;
|
|
234
|
+
approvedDocumentsCount?: Prisma.IntFilter<"DocumentationPhase"> | number;
|
|
235
|
+
requiredDocumentsCount?: Prisma.IntFilter<"DocumentationPhase"> | number;
|
|
236
|
+
completedStepsCount?: Prisma.IntFilter<"DocumentationPhase"> | number;
|
|
237
|
+
totalStepsCount?: Prisma.IntFilter<"DocumentationPhase"> | number;
|
|
238
|
+
minimumCompletionPercentage?: Prisma.FloatNullableFilter<"DocumentationPhase"> | number | null;
|
|
239
|
+
completionCriterion?: Prisma.EnumCompletionCriterionNullableFilter<"DocumentationPhase"> | $Enums.CompletionCriterion | null;
|
|
240
|
+
stepDefinitionsSnapshot?: Prisma.JsonNullableFilter<"DocumentationPhase">;
|
|
241
|
+
requiredDocumentSnapshot?: Prisma.JsonNullableFilter<"DocumentationPhase">;
|
|
242
|
+
createdAt?: Prisma.DateTimeFilter<"DocumentationPhase"> | Date | string;
|
|
243
|
+
updatedAt?: Prisma.DateTimeFilter<"DocumentationPhase"> | Date | string;
|
|
244
|
+
phase?: Prisma.XOR<Prisma.ContractPhaseScalarRelationFilter, Prisma.ContractPhaseWhereInput>;
|
|
245
|
+
currentStep?: Prisma.XOR<Prisma.DocumentationStepNullableScalarRelationFilter, Prisma.DocumentationStepWhereInput> | null;
|
|
246
|
+
steps?: Prisma.DocumentationStepListRelationFilter;
|
|
247
|
+
};
|
|
248
|
+
export type DocumentationPhaseOrderByWithRelationInput = {
|
|
249
|
+
id?: Prisma.SortOrder;
|
|
250
|
+
phaseId?: Prisma.SortOrder;
|
|
251
|
+
currentStepId?: Prisma.SortOrderInput | Prisma.SortOrder;
|
|
252
|
+
approvedDocumentsCount?: Prisma.SortOrder;
|
|
253
|
+
requiredDocumentsCount?: Prisma.SortOrder;
|
|
254
|
+
completedStepsCount?: Prisma.SortOrder;
|
|
255
|
+
totalStepsCount?: Prisma.SortOrder;
|
|
256
|
+
minimumCompletionPercentage?: Prisma.SortOrderInput | Prisma.SortOrder;
|
|
257
|
+
completionCriterion?: Prisma.SortOrderInput | Prisma.SortOrder;
|
|
258
|
+
stepDefinitionsSnapshot?: Prisma.SortOrderInput | Prisma.SortOrder;
|
|
259
|
+
requiredDocumentSnapshot?: Prisma.SortOrderInput | Prisma.SortOrder;
|
|
260
|
+
createdAt?: Prisma.SortOrder;
|
|
261
|
+
updatedAt?: Prisma.SortOrder;
|
|
262
|
+
phase?: Prisma.ContractPhaseOrderByWithRelationInput;
|
|
263
|
+
currentStep?: Prisma.DocumentationStepOrderByWithRelationInput;
|
|
264
|
+
steps?: Prisma.DocumentationStepOrderByRelationAggregateInput;
|
|
265
|
+
_relevance?: Prisma.DocumentationPhaseOrderByRelevanceInput;
|
|
266
|
+
};
|
|
267
|
+
export type DocumentationPhaseWhereUniqueInput = Prisma.AtLeast<{
|
|
268
|
+
id?: string;
|
|
269
|
+
phaseId?: string;
|
|
270
|
+
AND?: Prisma.DocumentationPhaseWhereInput | Prisma.DocumentationPhaseWhereInput[];
|
|
271
|
+
OR?: Prisma.DocumentationPhaseWhereInput[];
|
|
272
|
+
NOT?: Prisma.DocumentationPhaseWhereInput | Prisma.DocumentationPhaseWhereInput[];
|
|
273
|
+
currentStepId?: Prisma.StringNullableFilter<"DocumentationPhase"> | string | null;
|
|
274
|
+
approvedDocumentsCount?: Prisma.IntFilter<"DocumentationPhase"> | number;
|
|
275
|
+
requiredDocumentsCount?: Prisma.IntFilter<"DocumentationPhase"> | number;
|
|
276
|
+
completedStepsCount?: Prisma.IntFilter<"DocumentationPhase"> | number;
|
|
277
|
+
totalStepsCount?: Prisma.IntFilter<"DocumentationPhase"> | number;
|
|
278
|
+
minimumCompletionPercentage?: Prisma.FloatNullableFilter<"DocumentationPhase"> | number | null;
|
|
279
|
+
completionCriterion?: Prisma.EnumCompletionCriterionNullableFilter<"DocumentationPhase"> | $Enums.CompletionCriterion | null;
|
|
280
|
+
stepDefinitionsSnapshot?: Prisma.JsonNullableFilter<"DocumentationPhase">;
|
|
281
|
+
requiredDocumentSnapshot?: Prisma.JsonNullableFilter<"DocumentationPhase">;
|
|
282
|
+
createdAt?: Prisma.DateTimeFilter<"DocumentationPhase"> | Date | string;
|
|
283
|
+
updatedAt?: Prisma.DateTimeFilter<"DocumentationPhase"> | Date | string;
|
|
284
|
+
phase?: Prisma.XOR<Prisma.ContractPhaseScalarRelationFilter, Prisma.ContractPhaseWhereInput>;
|
|
285
|
+
currentStep?: Prisma.XOR<Prisma.DocumentationStepNullableScalarRelationFilter, Prisma.DocumentationStepWhereInput> | null;
|
|
286
|
+
steps?: Prisma.DocumentationStepListRelationFilter;
|
|
287
|
+
}, "id" | "phaseId">;
|
|
288
|
+
export type DocumentationPhaseOrderByWithAggregationInput = {
|
|
289
|
+
id?: Prisma.SortOrder;
|
|
290
|
+
phaseId?: Prisma.SortOrder;
|
|
291
|
+
currentStepId?: Prisma.SortOrderInput | Prisma.SortOrder;
|
|
292
|
+
approvedDocumentsCount?: Prisma.SortOrder;
|
|
293
|
+
requiredDocumentsCount?: Prisma.SortOrder;
|
|
294
|
+
completedStepsCount?: Prisma.SortOrder;
|
|
295
|
+
totalStepsCount?: Prisma.SortOrder;
|
|
296
|
+
minimumCompletionPercentage?: Prisma.SortOrderInput | Prisma.SortOrder;
|
|
297
|
+
completionCriterion?: Prisma.SortOrderInput | Prisma.SortOrder;
|
|
298
|
+
stepDefinitionsSnapshot?: Prisma.SortOrderInput | Prisma.SortOrder;
|
|
299
|
+
requiredDocumentSnapshot?: Prisma.SortOrderInput | Prisma.SortOrder;
|
|
300
|
+
createdAt?: Prisma.SortOrder;
|
|
301
|
+
updatedAt?: Prisma.SortOrder;
|
|
302
|
+
_count?: Prisma.DocumentationPhaseCountOrderByAggregateInput;
|
|
303
|
+
_avg?: Prisma.DocumentationPhaseAvgOrderByAggregateInput;
|
|
304
|
+
_max?: Prisma.DocumentationPhaseMaxOrderByAggregateInput;
|
|
305
|
+
_min?: Prisma.DocumentationPhaseMinOrderByAggregateInput;
|
|
306
|
+
_sum?: Prisma.DocumentationPhaseSumOrderByAggregateInput;
|
|
307
|
+
};
|
|
308
|
+
export type DocumentationPhaseScalarWhereWithAggregatesInput = {
|
|
309
|
+
AND?: Prisma.DocumentationPhaseScalarWhereWithAggregatesInput | Prisma.DocumentationPhaseScalarWhereWithAggregatesInput[];
|
|
310
|
+
OR?: Prisma.DocumentationPhaseScalarWhereWithAggregatesInput[];
|
|
311
|
+
NOT?: Prisma.DocumentationPhaseScalarWhereWithAggregatesInput | Prisma.DocumentationPhaseScalarWhereWithAggregatesInput[];
|
|
312
|
+
id?: Prisma.StringWithAggregatesFilter<"DocumentationPhase"> | string;
|
|
313
|
+
phaseId?: Prisma.StringWithAggregatesFilter<"DocumentationPhase"> | string;
|
|
314
|
+
currentStepId?: Prisma.StringNullableWithAggregatesFilter<"DocumentationPhase"> | string | null;
|
|
315
|
+
approvedDocumentsCount?: Prisma.IntWithAggregatesFilter<"DocumentationPhase"> | number;
|
|
316
|
+
requiredDocumentsCount?: Prisma.IntWithAggregatesFilter<"DocumentationPhase"> | number;
|
|
317
|
+
completedStepsCount?: Prisma.IntWithAggregatesFilter<"DocumentationPhase"> | number;
|
|
318
|
+
totalStepsCount?: Prisma.IntWithAggregatesFilter<"DocumentationPhase"> | number;
|
|
319
|
+
minimumCompletionPercentage?: Prisma.FloatNullableWithAggregatesFilter<"DocumentationPhase"> | number | null;
|
|
320
|
+
completionCriterion?: Prisma.EnumCompletionCriterionNullableWithAggregatesFilter<"DocumentationPhase"> | $Enums.CompletionCriterion | null;
|
|
321
|
+
stepDefinitionsSnapshot?: Prisma.JsonNullableWithAggregatesFilter<"DocumentationPhase">;
|
|
322
|
+
requiredDocumentSnapshot?: Prisma.JsonNullableWithAggregatesFilter<"DocumentationPhase">;
|
|
323
|
+
createdAt?: Prisma.DateTimeWithAggregatesFilter<"DocumentationPhase"> | Date | string;
|
|
324
|
+
updatedAt?: Prisma.DateTimeWithAggregatesFilter<"DocumentationPhase"> | Date | string;
|
|
325
|
+
};
|
|
326
|
+
export type DocumentationPhaseCreateInput = {
|
|
327
|
+
id?: string;
|
|
328
|
+
approvedDocumentsCount?: number;
|
|
329
|
+
requiredDocumentsCount?: number;
|
|
330
|
+
completedStepsCount?: number;
|
|
331
|
+
totalStepsCount?: number;
|
|
332
|
+
minimumCompletionPercentage?: number | null;
|
|
333
|
+
completionCriterion?: $Enums.CompletionCriterion | null;
|
|
334
|
+
stepDefinitionsSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
335
|
+
requiredDocumentSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
336
|
+
createdAt?: Date | string;
|
|
337
|
+
updatedAt?: Date | string;
|
|
338
|
+
phase: Prisma.ContractPhaseCreateNestedOneWithoutDocumentationPhaseInput;
|
|
339
|
+
currentStep?: Prisma.DocumentationStepCreateNestedOneWithoutCurrentForPhaseInput;
|
|
340
|
+
steps?: Prisma.DocumentationStepCreateNestedManyWithoutDocumentationPhaseInput;
|
|
341
|
+
};
|
|
342
|
+
export type DocumentationPhaseUncheckedCreateInput = {
|
|
343
|
+
id?: string;
|
|
344
|
+
phaseId: string;
|
|
345
|
+
currentStepId?: string | null;
|
|
346
|
+
approvedDocumentsCount?: number;
|
|
347
|
+
requiredDocumentsCount?: number;
|
|
348
|
+
completedStepsCount?: number;
|
|
349
|
+
totalStepsCount?: number;
|
|
350
|
+
minimumCompletionPercentage?: number | null;
|
|
351
|
+
completionCriterion?: $Enums.CompletionCriterion | null;
|
|
352
|
+
stepDefinitionsSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
353
|
+
requiredDocumentSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
354
|
+
createdAt?: Date | string;
|
|
355
|
+
updatedAt?: Date | string;
|
|
356
|
+
steps?: Prisma.DocumentationStepUncheckedCreateNestedManyWithoutDocumentationPhaseInput;
|
|
357
|
+
};
|
|
358
|
+
export type DocumentationPhaseUpdateInput = {
|
|
359
|
+
id?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
360
|
+
approvedDocumentsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
361
|
+
requiredDocumentsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
362
|
+
completedStepsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
363
|
+
totalStepsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
364
|
+
minimumCompletionPercentage?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null;
|
|
365
|
+
completionCriterion?: Prisma.NullableEnumCompletionCriterionFieldUpdateOperationsInput | $Enums.CompletionCriterion | null;
|
|
366
|
+
stepDefinitionsSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
367
|
+
requiredDocumentSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
368
|
+
createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
369
|
+
updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
370
|
+
phase?: Prisma.ContractPhaseUpdateOneRequiredWithoutDocumentationPhaseNestedInput;
|
|
371
|
+
currentStep?: Prisma.DocumentationStepUpdateOneWithoutCurrentForPhaseNestedInput;
|
|
372
|
+
steps?: Prisma.DocumentationStepUpdateManyWithoutDocumentationPhaseNestedInput;
|
|
373
|
+
};
|
|
374
|
+
export type DocumentationPhaseUncheckedUpdateInput = {
|
|
375
|
+
id?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
376
|
+
phaseId?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
377
|
+
currentStepId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
|
|
378
|
+
approvedDocumentsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
379
|
+
requiredDocumentsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
380
|
+
completedStepsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
381
|
+
totalStepsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
382
|
+
minimumCompletionPercentage?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null;
|
|
383
|
+
completionCriterion?: Prisma.NullableEnumCompletionCriterionFieldUpdateOperationsInput | $Enums.CompletionCriterion | null;
|
|
384
|
+
stepDefinitionsSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
385
|
+
requiredDocumentSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
386
|
+
createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
387
|
+
updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
388
|
+
steps?: Prisma.DocumentationStepUncheckedUpdateManyWithoutDocumentationPhaseNestedInput;
|
|
389
|
+
};
|
|
390
|
+
export type DocumentationPhaseCreateManyInput = {
|
|
391
|
+
id?: string;
|
|
392
|
+
phaseId: string;
|
|
393
|
+
currentStepId?: string | null;
|
|
394
|
+
approvedDocumentsCount?: number;
|
|
395
|
+
requiredDocumentsCount?: number;
|
|
396
|
+
completedStepsCount?: number;
|
|
397
|
+
totalStepsCount?: number;
|
|
398
|
+
minimumCompletionPercentage?: number | null;
|
|
399
|
+
completionCriterion?: $Enums.CompletionCriterion | null;
|
|
400
|
+
stepDefinitionsSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
401
|
+
requiredDocumentSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
402
|
+
createdAt?: Date | string;
|
|
403
|
+
updatedAt?: Date | string;
|
|
404
|
+
};
|
|
405
|
+
export type DocumentationPhaseUpdateManyMutationInput = {
|
|
406
|
+
id?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
407
|
+
approvedDocumentsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
408
|
+
requiredDocumentsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
409
|
+
completedStepsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
410
|
+
totalStepsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
411
|
+
minimumCompletionPercentage?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null;
|
|
412
|
+
completionCriterion?: Prisma.NullableEnumCompletionCriterionFieldUpdateOperationsInput | $Enums.CompletionCriterion | null;
|
|
413
|
+
stepDefinitionsSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
414
|
+
requiredDocumentSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
415
|
+
createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
416
|
+
updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
417
|
+
};
|
|
418
|
+
export type DocumentationPhaseUncheckedUpdateManyInput = {
|
|
419
|
+
id?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
420
|
+
phaseId?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
421
|
+
currentStepId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
|
|
422
|
+
approvedDocumentsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
423
|
+
requiredDocumentsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
424
|
+
completedStepsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
425
|
+
totalStepsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
426
|
+
minimumCompletionPercentage?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null;
|
|
427
|
+
completionCriterion?: Prisma.NullableEnumCompletionCriterionFieldUpdateOperationsInput | $Enums.CompletionCriterion | null;
|
|
428
|
+
stepDefinitionsSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
429
|
+
requiredDocumentSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
430
|
+
createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
431
|
+
updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
432
|
+
};
|
|
433
|
+
export type DocumentationPhaseNullableScalarRelationFilter = {
|
|
434
|
+
is?: Prisma.DocumentationPhaseWhereInput | null;
|
|
435
|
+
isNot?: Prisma.DocumentationPhaseWhereInput | null;
|
|
436
|
+
};
|
|
437
|
+
export type DocumentationPhaseOrderByRelevanceInput = {
|
|
438
|
+
fields: Prisma.DocumentationPhaseOrderByRelevanceFieldEnum | Prisma.DocumentationPhaseOrderByRelevanceFieldEnum[];
|
|
439
|
+
sort: Prisma.SortOrder;
|
|
440
|
+
search: string;
|
|
441
|
+
};
|
|
442
|
+
export type DocumentationPhaseCountOrderByAggregateInput = {
|
|
443
|
+
id?: Prisma.SortOrder;
|
|
444
|
+
phaseId?: Prisma.SortOrder;
|
|
445
|
+
currentStepId?: Prisma.SortOrder;
|
|
446
|
+
approvedDocumentsCount?: Prisma.SortOrder;
|
|
447
|
+
requiredDocumentsCount?: Prisma.SortOrder;
|
|
448
|
+
completedStepsCount?: Prisma.SortOrder;
|
|
449
|
+
totalStepsCount?: Prisma.SortOrder;
|
|
450
|
+
minimumCompletionPercentage?: Prisma.SortOrder;
|
|
451
|
+
completionCriterion?: Prisma.SortOrder;
|
|
452
|
+
stepDefinitionsSnapshot?: Prisma.SortOrder;
|
|
453
|
+
requiredDocumentSnapshot?: Prisma.SortOrder;
|
|
454
|
+
createdAt?: Prisma.SortOrder;
|
|
455
|
+
updatedAt?: Prisma.SortOrder;
|
|
456
|
+
};
|
|
457
|
+
export type DocumentationPhaseAvgOrderByAggregateInput = {
|
|
458
|
+
approvedDocumentsCount?: Prisma.SortOrder;
|
|
459
|
+
requiredDocumentsCount?: Prisma.SortOrder;
|
|
460
|
+
completedStepsCount?: Prisma.SortOrder;
|
|
461
|
+
totalStepsCount?: Prisma.SortOrder;
|
|
462
|
+
minimumCompletionPercentage?: Prisma.SortOrder;
|
|
463
|
+
};
|
|
464
|
+
export type DocumentationPhaseMaxOrderByAggregateInput = {
|
|
465
|
+
id?: Prisma.SortOrder;
|
|
466
|
+
phaseId?: Prisma.SortOrder;
|
|
467
|
+
currentStepId?: Prisma.SortOrder;
|
|
468
|
+
approvedDocumentsCount?: Prisma.SortOrder;
|
|
469
|
+
requiredDocumentsCount?: Prisma.SortOrder;
|
|
470
|
+
completedStepsCount?: Prisma.SortOrder;
|
|
471
|
+
totalStepsCount?: Prisma.SortOrder;
|
|
472
|
+
minimumCompletionPercentage?: Prisma.SortOrder;
|
|
473
|
+
completionCriterion?: Prisma.SortOrder;
|
|
474
|
+
createdAt?: Prisma.SortOrder;
|
|
475
|
+
updatedAt?: Prisma.SortOrder;
|
|
476
|
+
};
|
|
477
|
+
export type DocumentationPhaseMinOrderByAggregateInput = {
|
|
478
|
+
id?: Prisma.SortOrder;
|
|
479
|
+
phaseId?: Prisma.SortOrder;
|
|
480
|
+
currentStepId?: Prisma.SortOrder;
|
|
481
|
+
approvedDocumentsCount?: Prisma.SortOrder;
|
|
482
|
+
requiredDocumentsCount?: Prisma.SortOrder;
|
|
483
|
+
completedStepsCount?: Prisma.SortOrder;
|
|
484
|
+
totalStepsCount?: Prisma.SortOrder;
|
|
485
|
+
minimumCompletionPercentage?: Prisma.SortOrder;
|
|
486
|
+
completionCriterion?: Prisma.SortOrder;
|
|
487
|
+
createdAt?: Prisma.SortOrder;
|
|
488
|
+
updatedAt?: Prisma.SortOrder;
|
|
489
|
+
};
|
|
490
|
+
export type DocumentationPhaseSumOrderByAggregateInput = {
|
|
491
|
+
approvedDocumentsCount?: Prisma.SortOrder;
|
|
492
|
+
requiredDocumentsCount?: Prisma.SortOrder;
|
|
493
|
+
completedStepsCount?: Prisma.SortOrder;
|
|
494
|
+
totalStepsCount?: Prisma.SortOrder;
|
|
495
|
+
minimumCompletionPercentage?: Prisma.SortOrder;
|
|
496
|
+
};
|
|
497
|
+
export type DocumentationPhaseScalarRelationFilter = {
|
|
498
|
+
is?: Prisma.DocumentationPhaseWhereInput;
|
|
499
|
+
isNot?: Prisma.DocumentationPhaseWhereInput;
|
|
500
|
+
};
|
|
501
|
+
export type DocumentationPhaseListRelationFilter = {
|
|
502
|
+
every?: Prisma.DocumentationPhaseWhereInput;
|
|
503
|
+
some?: Prisma.DocumentationPhaseWhereInput;
|
|
504
|
+
none?: Prisma.DocumentationPhaseWhereInput;
|
|
505
|
+
};
|
|
506
|
+
export type DocumentationPhaseOrderByRelationAggregateInput = {
|
|
507
|
+
_count?: Prisma.SortOrder;
|
|
508
|
+
};
|
|
509
|
+
export type DocumentationPhaseCreateNestedOneWithoutPhaseInput = {
|
|
510
|
+
create?: Prisma.XOR<Prisma.DocumentationPhaseCreateWithoutPhaseInput, Prisma.DocumentationPhaseUncheckedCreateWithoutPhaseInput>;
|
|
511
|
+
connectOrCreate?: Prisma.DocumentationPhaseCreateOrConnectWithoutPhaseInput;
|
|
512
|
+
connect?: Prisma.DocumentationPhaseWhereUniqueInput;
|
|
513
|
+
};
|
|
514
|
+
export type DocumentationPhaseUncheckedCreateNestedOneWithoutPhaseInput = {
|
|
515
|
+
create?: Prisma.XOR<Prisma.DocumentationPhaseCreateWithoutPhaseInput, Prisma.DocumentationPhaseUncheckedCreateWithoutPhaseInput>;
|
|
516
|
+
connectOrCreate?: Prisma.DocumentationPhaseCreateOrConnectWithoutPhaseInput;
|
|
517
|
+
connect?: Prisma.DocumentationPhaseWhereUniqueInput;
|
|
518
|
+
};
|
|
519
|
+
export type DocumentationPhaseUpdateOneWithoutPhaseNestedInput = {
|
|
520
|
+
create?: Prisma.XOR<Prisma.DocumentationPhaseCreateWithoutPhaseInput, Prisma.DocumentationPhaseUncheckedCreateWithoutPhaseInput>;
|
|
521
|
+
connectOrCreate?: Prisma.DocumentationPhaseCreateOrConnectWithoutPhaseInput;
|
|
522
|
+
upsert?: Prisma.DocumentationPhaseUpsertWithoutPhaseInput;
|
|
523
|
+
disconnect?: Prisma.DocumentationPhaseWhereInput | boolean;
|
|
524
|
+
delete?: Prisma.DocumentationPhaseWhereInput | boolean;
|
|
525
|
+
connect?: Prisma.DocumentationPhaseWhereUniqueInput;
|
|
526
|
+
update?: Prisma.XOR<Prisma.XOR<Prisma.DocumentationPhaseUpdateToOneWithWhereWithoutPhaseInput, Prisma.DocumentationPhaseUpdateWithoutPhaseInput>, Prisma.DocumentationPhaseUncheckedUpdateWithoutPhaseInput>;
|
|
527
|
+
};
|
|
528
|
+
export type DocumentationPhaseUncheckedUpdateOneWithoutPhaseNestedInput = {
|
|
529
|
+
create?: Prisma.XOR<Prisma.DocumentationPhaseCreateWithoutPhaseInput, Prisma.DocumentationPhaseUncheckedCreateWithoutPhaseInput>;
|
|
530
|
+
connectOrCreate?: Prisma.DocumentationPhaseCreateOrConnectWithoutPhaseInput;
|
|
531
|
+
upsert?: Prisma.DocumentationPhaseUpsertWithoutPhaseInput;
|
|
532
|
+
disconnect?: Prisma.DocumentationPhaseWhereInput | boolean;
|
|
533
|
+
delete?: Prisma.DocumentationPhaseWhereInput | boolean;
|
|
534
|
+
connect?: Prisma.DocumentationPhaseWhereUniqueInput;
|
|
535
|
+
update?: Prisma.XOR<Prisma.XOR<Prisma.DocumentationPhaseUpdateToOneWithWhereWithoutPhaseInput, Prisma.DocumentationPhaseUpdateWithoutPhaseInput>, Prisma.DocumentationPhaseUncheckedUpdateWithoutPhaseInput>;
|
|
536
|
+
};
|
|
537
|
+
export type DocumentationPhaseCreateNestedOneWithoutStepsInput = {
|
|
538
|
+
create?: Prisma.XOR<Prisma.DocumentationPhaseCreateWithoutStepsInput, Prisma.DocumentationPhaseUncheckedCreateWithoutStepsInput>;
|
|
539
|
+
connectOrCreate?: Prisma.DocumentationPhaseCreateOrConnectWithoutStepsInput;
|
|
540
|
+
connect?: Prisma.DocumentationPhaseWhereUniqueInput;
|
|
541
|
+
};
|
|
542
|
+
export type DocumentationPhaseCreateNestedManyWithoutCurrentStepInput = {
|
|
543
|
+
create?: Prisma.XOR<Prisma.DocumentationPhaseCreateWithoutCurrentStepInput, Prisma.DocumentationPhaseUncheckedCreateWithoutCurrentStepInput> | Prisma.DocumentationPhaseCreateWithoutCurrentStepInput[] | Prisma.DocumentationPhaseUncheckedCreateWithoutCurrentStepInput[];
|
|
544
|
+
connectOrCreate?: Prisma.DocumentationPhaseCreateOrConnectWithoutCurrentStepInput | Prisma.DocumentationPhaseCreateOrConnectWithoutCurrentStepInput[];
|
|
545
|
+
createMany?: Prisma.DocumentationPhaseCreateManyCurrentStepInputEnvelope;
|
|
546
|
+
connect?: Prisma.DocumentationPhaseWhereUniqueInput | Prisma.DocumentationPhaseWhereUniqueInput[];
|
|
547
|
+
};
|
|
548
|
+
export type DocumentationPhaseUncheckedCreateNestedManyWithoutCurrentStepInput = {
|
|
549
|
+
create?: Prisma.XOR<Prisma.DocumentationPhaseCreateWithoutCurrentStepInput, Prisma.DocumentationPhaseUncheckedCreateWithoutCurrentStepInput> | Prisma.DocumentationPhaseCreateWithoutCurrentStepInput[] | Prisma.DocumentationPhaseUncheckedCreateWithoutCurrentStepInput[];
|
|
550
|
+
connectOrCreate?: Prisma.DocumentationPhaseCreateOrConnectWithoutCurrentStepInput | Prisma.DocumentationPhaseCreateOrConnectWithoutCurrentStepInput[];
|
|
551
|
+
createMany?: Prisma.DocumentationPhaseCreateManyCurrentStepInputEnvelope;
|
|
552
|
+
connect?: Prisma.DocumentationPhaseWhereUniqueInput | Prisma.DocumentationPhaseWhereUniqueInput[];
|
|
553
|
+
};
|
|
554
|
+
export type DocumentationPhaseUpdateOneRequiredWithoutStepsNestedInput = {
|
|
555
|
+
create?: Prisma.XOR<Prisma.DocumentationPhaseCreateWithoutStepsInput, Prisma.DocumentationPhaseUncheckedCreateWithoutStepsInput>;
|
|
556
|
+
connectOrCreate?: Prisma.DocumentationPhaseCreateOrConnectWithoutStepsInput;
|
|
557
|
+
upsert?: Prisma.DocumentationPhaseUpsertWithoutStepsInput;
|
|
558
|
+
connect?: Prisma.DocumentationPhaseWhereUniqueInput;
|
|
559
|
+
update?: Prisma.XOR<Prisma.XOR<Prisma.DocumentationPhaseUpdateToOneWithWhereWithoutStepsInput, Prisma.DocumentationPhaseUpdateWithoutStepsInput>, Prisma.DocumentationPhaseUncheckedUpdateWithoutStepsInput>;
|
|
560
|
+
};
|
|
561
|
+
export type DocumentationPhaseUpdateManyWithoutCurrentStepNestedInput = {
|
|
562
|
+
create?: Prisma.XOR<Prisma.DocumentationPhaseCreateWithoutCurrentStepInput, Prisma.DocumentationPhaseUncheckedCreateWithoutCurrentStepInput> | Prisma.DocumentationPhaseCreateWithoutCurrentStepInput[] | Prisma.DocumentationPhaseUncheckedCreateWithoutCurrentStepInput[];
|
|
563
|
+
connectOrCreate?: Prisma.DocumentationPhaseCreateOrConnectWithoutCurrentStepInput | Prisma.DocumentationPhaseCreateOrConnectWithoutCurrentStepInput[];
|
|
564
|
+
upsert?: Prisma.DocumentationPhaseUpsertWithWhereUniqueWithoutCurrentStepInput | Prisma.DocumentationPhaseUpsertWithWhereUniqueWithoutCurrentStepInput[];
|
|
565
|
+
createMany?: Prisma.DocumentationPhaseCreateManyCurrentStepInputEnvelope;
|
|
566
|
+
set?: Prisma.DocumentationPhaseWhereUniqueInput | Prisma.DocumentationPhaseWhereUniqueInput[];
|
|
567
|
+
disconnect?: Prisma.DocumentationPhaseWhereUniqueInput | Prisma.DocumentationPhaseWhereUniqueInput[];
|
|
568
|
+
delete?: Prisma.DocumentationPhaseWhereUniqueInput | Prisma.DocumentationPhaseWhereUniqueInput[];
|
|
569
|
+
connect?: Prisma.DocumentationPhaseWhereUniqueInput | Prisma.DocumentationPhaseWhereUniqueInput[];
|
|
570
|
+
update?: Prisma.DocumentationPhaseUpdateWithWhereUniqueWithoutCurrentStepInput | Prisma.DocumentationPhaseUpdateWithWhereUniqueWithoutCurrentStepInput[];
|
|
571
|
+
updateMany?: Prisma.DocumentationPhaseUpdateManyWithWhereWithoutCurrentStepInput | Prisma.DocumentationPhaseUpdateManyWithWhereWithoutCurrentStepInput[];
|
|
572
|
+
deleteMany?: Prisma.DocumentationPhaseScalarWhereInput | Prisma.DocumentationPhaseScalarWhereInput[];
|
|
573
|
+
};
|
|
574
|
+
export type DocumentationPhaseUncheckedUpdateManyWithoutCurrentStepNestedInput = {
|
|
575
|
+
create?: Prisma.XOR<Prisma.DocumentationPhaseCreateWithoutCurrentStepInput, Prisma.DocumentationPhaseUncheckedCreateWithoutCurrentStepInput> | Prisma.DocumentationPhaseCreateWithoutCurrentStepInput[] | Prisma.DocumentationPhaseUncheckedCreateWithoutCurrentStepInput[];
|
|
576
|
+
connectOrCreate?: Prisma.DocumentationPhaseCreateOrConnectWithoutCurrentStepInput | Prisma.DocumentationPhaseCreateOrConnectWithoutCurrentStepInput[];
|
|
577
|
+
upsert?: Prisma.DocumentationPhaseUpsertWithWhereUniqueWithoutCurrentStepInput | Prisma.DocumentationPhaseUpsertWithWhereUniqueWithoutCurrentStepInput[];
|
|
578
|
+
createMany?: Prisma.DocumentationPhaseCreateManyCurrentStepInputEnvelope;
|
|
579
|
+
set?: Prisma.DocumentationPhaseWhereUniqueInput | Prisma.DocumentationPhaseWhereUniqueInput[];
|
|
580
|
+
disconnect?: Prisma.DocumentationPhaseWhereUniqueInput | Prisma.DocumentationPhaseWhereUniqueInput[];
|
|
581
|
+
delete?: Prisma.DocumentationPhaseWhereUniqueInput | Prisma.DocumentationPhaseWhereUniqueInput[];
|
|
582
|
+
connect?: Prisma.DocumentationPhaseWhereUniqueInput | Prisma.DocumentationPhaseWhereUniqueInput[];
|
|
583
|
+
update?: Prisma.DocumentationPhaseUpdateWithWhereUniqueWithoutCurrentStepInput | Prisma.DocumentationPhaseUpdateWithWhereUniqueWithoutCurrentStepInput[];
|
|
584
|
+
updateMany?: Prisma.DocumentationPhaseUpdateManyWithWhereWithoutCurrentStepInput | Prisma.DocumentationPhaseUpdateManyWithWhereWithoutCurrentStepInput[];
|
|
585
|
+
deleteMany?: Prisma.DocumentationPhaseScalarWhereInput | Prisma.DocumentationPhaseScalarWhereInput[];
|
|
586
|
+
};
|
|
587
|
+
export type DocumentationPhaseCreateWithoutPhaseInput = {
|
|
588
|
+
id?: string;
|
|
589
|
+
approvedDocumentsCount?: number;
|
|
590
|
+
requiredDocumentsCount?: number;
|
|
591
|
+
completedStepsCount?: number;
|
|
592
|
+
totalStepsCount?: number;
|
|
593
|
+
minimumCompletionPercentage?: number | null;
|
|
594
|
+
completionCriterion?: $Enums.CompletionCriterion | null;
|
|
595
|
+
stepDefinitionsSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
596
|
+
requiredDocumentSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
597
|
+
createdAt?: Date | string;
|
|
598
|
+
updatedAt?: Date | string;
|
|
599
|
+
currentStep?: Prisma.DocumentationStepCreateNestedOneWithoutCurrentForPhaseInput;
|
|
600
|
+
steps?: Prisma.DocumentationStepCreateNestedManyWithoutDocumentationPhaseInput;
|
|
601
|
+
};
|
|
602
|
+
export type DocumentationPhaseUncheckedCreateWithoutPhaseInput = {
|
|
603
|
+
id?: string;
|
|
604
|
+
currentStepId?: string | null;
|
|
605
|
+
approvedDocumentsCount?: number;
|
|
606
|
+
requiredDocumentsCount?: number;
|
|
607
|
+
completedStepsCount?: number;
|
|
608
|
+
totalStepsCount?: number;
|
|
609
|
+
minimumCompletionPercentage?: number | null;
|
|
610
|
+
completionCriterion?: $Enums.CompletionCriterion | null;
|
|
611
|
+
stepDefinitionsSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
612
|
+
requiredDocumentSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
613
|
+
createdAt?: Date | string;
|
|
614
|
+
updatedAt?: Date | string;
|
|
615
|
+
steps?: Prisma.DocumentationStepUncheckedCreateNestedManyWithoutDocumentationPhaseInput;
|
|
616
|
+
};
|
|
617
|
+
export type DocumentationPhaseCreateOrConnectWithoutPhaseInput = {
|
|
618
|
+
where: Prisma.DocumentationPhaseWhereUniqueInput;
|
|
619
|
+
create: Prisma.XOR<Prisma.DocumentationPhaseCreateWithoutPhaseInput, Prisma.DocumentationPhaseUncheckedCreateWithoutPhaseInput>;
|
|
620
|
+
};
|
|
621
|
+
export type DocumentationPhaseUpsertWithoutPhaseInput = {
|
|
622
|
+
update: Prisma.XOR<Prisma.DocumentationPhaseUpdateWithoutPhaseInput, Prisma.DocumentationPhaseUncheckedUpdateWithoutPhaseInput>;
|
|
623
|
+
create: Prisma.XOR<Prisma.DocumentationPhaseCreateWithoutPhaseInput, Prisma.DocumentationPhaseUncheckedCreateWithoutPhaseInput>;
|
|
624
|
+
where?: Prisma.DocumentationPhaseWhereInput;
|
|
625
|
+
};
|
|
626
|
+
export type DocumentationPhaseUpdateToOneWithWhereWithoutPhaseInput = {
|
|
627
|
+
where?: Prisma.DocumentationPhaseWhereInput;
|
|
628
|
+
data: Prisma.XOR<Prisma.DocumentationPhaseUpdateWithoutPhaseInput, Prisma.DocumentationPhaseUncheckedUpdateWithoutPhaseInput>;
|
|
629
|
+
};
|
|
630
|
+
export type DocumentationPhaseUpdateWithoutPhaseInput = {
|
|
631
|
+
id?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
632
|
+
approvedDocumentsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
633
|
+
requiredDocumentsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
634
|
+
completedStepsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
635
|
+
totalStepsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
636
|
+
minimumCompletionPercentage?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null;
|
|
637
|
+
completionCriterion?: Prisma.NullableEnumCompletionCriterionFieldUpdateOperationsInput | $Enums.CompletionCriterion | null;
|
|
638
|
+
stepDefinitionsSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
639
|
+
requiredDocumentSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
640
|
+
createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
641
|
+
updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
642
|
+
currentStep?: Prisma.DocumentationStepUpdateOneWithoutCurrentForPhaseNestedInput;
|
|
643
|
+
steps?: Prisma.DocumentationStepUpdateManyWithoutDocumentationPhaseNestedInput;
|
|
644
|
+
};
|
|
645
|
+
export type DocumentationPhaseUncheckedUpdateWithoutPhaseInput = {
|
|
646
|
+
id?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
647
|
+
currentStepId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
|
|
648
|
+
approvedDocumentsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
649
|
+
requiredDocumentsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
650
|
+
completedStepsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
651
|
+
totalStepsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
652
|
+
minimumCompletionPercentage?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null;
|
|
653
|
+
completionCriterion?: Prisma.NullableEnumCompletionCriterionFieldUpdateOperationsInput | $Enums.CompletionCriterion | null;
|
|
654
|
+
stepDefinitionsSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
655
|
+
requiredDocumentSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
656
|
+
createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
657
|
+
updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
658
|
+
steps?: Prisma.DocumentationStepUncheckedUpdateManyWithoutDocumentationPhaseNestedInput;
|
|
659
|
+
};
|
|
660
|
+
export type DocumentationPhaseCreateWithoutStepsInput = {
|
|
661
|
+
id?: string;
|
|
662
|
+
approvedDocumentsCount?: number;
|
|
663
|
+
requiredDocumentsCount?: number;
|
|
664
|
+
completedStepsCount?: number;
|
|
665
|
+
totalStepsCount?: number;
|
|
666
|
+
minimumCompletionPercentage?: number | null;
|
|
667
|
+
completionCriterion?: $Enums.CompletionCriterion | null;
|
|
668
|
+
stepDefinitionsSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
669
|
+
requiredDocumentSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
670
|
+
createdAt?: Date | string;
|
|
671
|
+
updatedAt?: Date | string;
|
|
672
|
+
phase: Prisma.ContractPhaseCreateNestedOneWithoutDocumentationPhaseInput;
|
|
673
|
+
currentStep?: Prisma.DocumentationStepCreateNestedOneWithoutCurrentForPhaseInput;
|
|
674
|
+
};
|
|
675
|
+
export type DocumentationPhaseUncheckedCreateWithoutStepsInput = {
|
|
676
|
+
id?: string;
|
|
677
|
+
phaseId: string;
|
|
678
|
+
currentStepId?: string | null;
|
|
679
|
+
approvedDocumentsCount?: number;
|
|
680
|
+
requiredDocumentsCount?: number;
|
|
681
|
+
completedStepsCount?: number;
|
|
682
|
+
totalStepsCount?: number;
|
|
683
|
+
minimumCompletionPercentage?: number | null;
|
|
684
|
+
completionCriterion?: $Enums.CompletionCriterion | null;
|
|
685
|
+
stepDefinitionsSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
686
|
+
requiredDocumentSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
687
|
+
createdAt?: Date | string;
|
|
688
|
+
updatedAt?: Date | string;
|
|
689
|
+
};
|
|
690
|
+
export type DocumentationPhaseCreateOrConnectWithoutStepsInput = {
|
|
691
|
+
where: Prisma.DocumentationPhaseWhereUniqueInput;
|
|
692
|
+
create: Prisma.XOR<Prisma.DocumentationPhaseCreateWithoutStepsInput, Prisma.DocumentationPhaseUncheckedCreateWithoutStepsInput>;
|
|
693
|
+
};
|
|
694
|
+
export type DocumentationPhaseCreateWithoutCurrentStepInput = {
|
|
695
|
+
id?: string;
|
|
696
|
+
approvedDocumentsCount?: number;
|
|
697
|
+
requiredDocumentsCount?: number;
|
|
698
|
+
completedStepsCount?: number;
|
|
699
|
+
totalStepsCount?: number;
|
|
700
|
+
minimumCompletionPercentage?: number | null;
|
|
701
|
+
completionCriterion?: $Enums.CompletionCriterion | null;
|
|
702
|
+
stepDefinitionsSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
703
|
+
requiredDocumentSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
704
|
+
createdAt?: Date | string;
|
|
705
|
+
updatedAt?: Date | string;
|
|
706
|
+
phase: Prisma.ContractPhaseCreateNestedOneWithoutDocumentationPhaseInput;
|
|
707
|
+
steps?: Prisma.DocumentationStepCreateNestedManyWithoutDocumentationPhaseInput;
|
|
708
|
+
};
|
|
709
|
+
export type DocumentationPhaseUncheckedCreateWithoutCurrentStepInput = {
|
|
710
|
+
id?: string;
|
|
711
|
+
phaseId: string;
|
|
712
|
+
approvedDocumentsCount?: number;
|
|
713
|
+
requiredDocumentsCount?: number;
|
|
714
|
+
completedStepsCount?: number;
|
|
715
|
+
totalStepsCount?: number;
|
|
716
|
+
minimumCompletionPercentage?: number | null;
|
|
717
|
+
completionCriterion?: $Enums.CompletionCriterion | null;
|
|
718
|
+
stepDefinitionsSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
719
|
+
requiredDocumentSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
720
|
+
createdAt?: Date | string;
|
|
721
|
+
updatedAt?: Date | string;
|
|
722
|
+
steps?: Prisma.DocumentationStepUncheckedCreateNestedManyWithoutDocumentationPhaseInput;
|
|
723
|
+
};
|
|
724
|
+
export type DocumentationPhaseCreateOrConnectWithoutCurrentStepInput = {
|
|
725
|
+
where: Prisma.DocumentationPhaseWhereUniqueInput;
|
|
726
|
+
create: Prisma.XOR<Prisma.DocumentationPhaseCreateWithoutCurrentStepInput, Prisma.DocumentationPhaseUncheckedCreateWithoutCurrentStepInput>;
|
|
727
|
+
};
|
|
728
|
+
export type DocumentationPhaseCreateManyCurrentStepInputEnvelope = {
|
|
729
|
+
data: Prisma.DocumentationPhaseCreateManyCurrentStepInput | Prisma.DocumentationPhaseCreateManyCurrentStepInput[];
|
|
730
|
+
skipDuplicates?: boolean;
|
|
731
|
+
};
|
|
732
|
+
export type DocumentationPhaseUpsertWithoutStepsInput = {
|
|
733
|
+
update: Prisma.XOR<Prisma.DocumentationPhaseUpdateWithoutStepsInput, Prisma.DocumentationPhaseUncheckedUpdateWithoutStepsInput>;
|
|
734
|
+
create: Prisma.XOR<Prisma.DocumentationPhaseCreateWithoutStepsInput, Prisma.DocumentationPhaseUncheckedCreateWithoutStepsInput>;
|
|
735
|
+
where?: Prisma.DocumentationPhaseWhereInput;
|
|
736
|
+
};
|
|
737
|
+
export type DocumentationPhaseUpdateToOneWithWhereWithoutStepsInput = {
|
|
738
|
+
where?: Prisma.DocumentationPhaseWhereInput;
|
|
739
|
+
data: Prisma.XOR<Prisma.DocumentationPhaseUpdateWithoutStepsInput, Prisma.DocumentationPhaseUncheckedUpdateWithoutStepsInput>;
|
|
740
|
+
};
|
|
741
|
+
export type DocumentationPhaseUpdateWithoutStepsInput = {
|
|
742
|
+
id?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
743
|
+
approvedDocumentsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
744
|
+
requiredDocumentsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
745
|
+
completedStepsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
746
|
+
totalStepsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
747
|
+
minimumCompletionPercentage?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null;
|
|
748
|
+
completionCriterion?: Prisma.NullableEnumCompletionCriterionFieldUpdateOperationsInput | $Enums.CompletionCriterion | null;
|
|
749
|
+
stepDefinitionsSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
750
|
+
requiredDocumentSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
751
|
+
createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
752
|
+
updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
753
|
+
phase?: Prisma.ContractPhaseUpdateOneRequiredWithoutDocumentationPhaseNestedInput;
|
|
754
|
+
currentStep?: Prisma.DocumentationStepUpdateOneWithoutCurrentForPhaseNestedInput;
|
|
755
|
+
};
|
|
756
|
+
export type DocumentationPhaseUncheckedUpdateWithoutStepsInput = {
|
|
757
|
+
id?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
758
|
+
phaseId?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
759
|
+
currentStepId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
|
|
760
|
+
approvedDocumentsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
761
|
+
requiredDocumentsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
762
|
+
completedStepsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
763
|
+
totalStepsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
764
|
+
minimumCompletionPercentage?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null;
|
|
765
|
+
completionCriterion?: Prisma.NullableEnumCompletionCriterionFieldUpdateOperationsInput | $Enums.CompletionCriterion | null;
|
|
766
|
+
stepDefinitionsSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
767
|
+
requiredDocumentSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
768
|
+
createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
769
|
+
updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
770
|
+
};
|
|
771
|
+
export type DocumentationPhaseUpsertWithWhereUniqueWithoutCurrentStepInput = {
|
|
772
|
+
where: Prisma.DocumentationPhaseWhereUniqueInput;
|
|
773
|
+
update: Prisma.XOR<Prisma.DocumentationPhaseUpdateWithoutCurrentStepInput, Prisma.DocumentationPhaseUncheckedUpdateWithoutCurrentStepInput>;
|
|
774
|
+
create: Prisma.XOR<Prisma.DocumentationPhaseCreateWithoutCurrentStepInput, Prisma.DocumentationPhaseUncheckedCreateWithoutCurrentStepInput>;
|
|
775
|
+
};
|
|
776
|
+
export type DocumentationPhaseUpdateWithWhereUniqueWithoutCurrentStepInput = {
|
|
777
|
+
where: Prisma.DocumentationPhaseWhereUniqueInput;
|
|
778
|
+
data: Prisma.XOR<Prisma.DocumentationPhaseUpdateWithoutCurrentStepInput, Prisma.DocumentationPhaseUncheckedUpdateWithoutCurrentStepInput>;
|
|
779
|
+
};
|
|
780
|
+
export type DocumentationPhaseUpdateManyWithWhereWithoutCurrentStepInput = {
|
|
781
|
+
where: Prisma.DocumentationPhaseScalarWhereInput;
|
|
782
|
+
data: Prisma.XOR<Prisma.DocumentationPhaseUpdateManyMutationInput, Prisma.DocumentationPhaseUncheckedUpdateManyWithoutCurrentStepInput>;
|
|
783
|
+
};
|
|
784
|
+
export type DocumentationPhaseScalarWhereInput = {
|
|
785
|
+
AND?: Prisma.DocumentationPhaseScalarWhereInput | Prisma.DocumentationPhaseScalarWhereInput[];
|
|
786
|
+
OR?: Prisma.DocumentationPhaseScalarWhereInput[];
|
|
787
|
+
NOT?: Prisma.DocumentationPhaseScalarWhereInput | Prisma.DocumentationPhaseScalarWhereInput[];
|
|
788
|
+
id?: Prisma.StringFilter<"DocumentationPhase"> | string;
|
|
789
|
+
phaseId?: Prisma.StringFilter<"DocumentationPhase"> | string;
|
|
790
|
+
currentStepId?: Prisma.StringNullableFilter<"DocumentationPhase"> | string | null;
|
|
791
|
+
approvedDocumentsCount?: Prisma.IntFilter<"DocumentationPhase"> | number;
|
|
792
|
+
requiredDocumentsCount?: Prisma.IntFilter<"DocumentationPhase"> | number;
|
|
793
|
+
completedStepsCount?: Prisma.IntFilter<"DocumentationPhase"> | number;
|
|
794
|
+
totalStepsCount?: Prisma.IntFilter<"DocumentationPhase"> | number;
|
|
795
|
+
minimumCompletionPercentage?: Prisma.FloatNullableFilter<"DocumentationPhase"> | number | null;
|
|
796
|
+
completionCriterion?: Prisma.EnumCompletionCriterionNullableFilter<"DocumentationPhase"> | $Enums.CompletionCriterion | null;
|
|
797
|
+
stepDefinitionsSnapshot?: Prisma.JsonNullableFilter<"DocumentationPhase">;
|
|
798
|
+
requiredDocumentSnapshot?: Prisma.JsonNullableFilter<"DocumentationPhase">;
|
|
799
|
+
createdAt?: Prisma.DateTimeFilter<"DocumentationPhase"> | Date | string;
|
|
800
|
+
updatedAt?: Prisma.DateTimeFilter<"DocumentationPhase"> | Date | string;
|
|
801
|
+
};
|
|
802
|
+
export type DocumentationPhaseCreateManyCurrentStepInput = {
|
|
803
|
+
id?: string;
|
|
804
|
+
phaseId: string;
|
|
805
|
+
approvedDocumentsCount?: number;
|
|
806
|
+
requiredDocumentsCount?: number;
|
|
807
|
+
completedStepsCount?: number;
|
|
808
|
+
totalStepsCount?: number;
|
|
809
|
+
minimumCompletionPercentage?: number | null;
|
|
810
|
+
completionCriterion?: $Enums.CompletionCriterion | null;
|
|
811
|
+
stepDefinitionsSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
812
|
+
requiredDocumentSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
813
|
+
createdAt?: Date | string;
|
|
814
|
+
updatedAt?: Date | string;
|
|
815
|
+
};
|
|
816
|
+
export type DocumentationPhaseUpdateWithoutCurrentStepInput = {
|
|
817
|
+
id?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
818
|
+
approvedDocumentsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
819
|
+
requiredDocumentsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
820
|
+
completedStepsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
821
|
+
totalStepsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
822
|
+
minimumCompletionPercentage?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null;
|
|
823
|
+
completionCriterion?: Prisma.NullableEnumCompletionCriterionFieldUpdateOperationsInput | $Enums.CompletionCriterion | null;
|
|
824
|
+
stepDefinitionsSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
825
|
+
requiredDocumentSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
826
|
+
createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
827
|
+
updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
828
|
+
phase?: Prisma.ContractPhaseUpdateOneRequiredWithoutDocumentationPhaseNestedInput;
|
|
829
|
+
steps?: Prisma.DocumentationStepUpdateManyWithoutDocumentationPhaseNestedInput;
|
|
830
|
+
};
|
|
831
|
+
export type DocumentationPhaseUncheckedUpdateWithoutCurrentStepInput = {
|
|
832
|
+
id?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
833
|
+
phaseId?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
834
|
+
approvedDocumentsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
835
|
+
requiredDocumentsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
836
|
+
completedStepsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
837
|
+
totalStepsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
838
|
+
minimumCompletionPercentage?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null;
|
|
839
|
+
completionCriterion?: Prisma.NullableEnumCompletionCriterionFieldUpdateOperationsInput | $Enums.CompletionCriterion | null;
|
|
840
|
+
stepDefinitionsSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
841
|
+
requiredDocumentSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
842
|
+
createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
843
|
+
updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
844
|
+
steps?: Prisma.DocumentationStepUncheckedUpdateManyWithoutDocumentationPhaseNestedInput;
|
|
845
|
+
};
|
|
846
|
+
export type DocumentationPhaseUncheckedUpdateManyWithoutCurrentStepInput = {
|
|
847
|
+
id?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
848
|
+
phaseId?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
849
|
+
approvedDocumentsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
850
|
+
requiredDocumentsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
851
|
+
completedStepsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
852
|
+
totalStepsCount?: Prisma.IntFieldUpdateOperationsInput | number;
|
|
853
|
+
minimumCompletionPercentage?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null;
|
|
854
|
+
completionCriterion?: Prisma.NullableEnumCompletionCriterionFieldUpdateOperationsInput | $Enums.CompletionCriterion | null;
|
|
855
|
+
stepDefinitionsSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
856
|
+
requiredDocumentSnapshot?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue;
|
|
857
|
+
createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
858
|
+
updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
859
|
+
};
|
|
860
|
+
/**
|
|
861
|
+
* Count Type DocumentationPhaseCountOutputType
|
|
862
|
+
*/
|
|
863
|
+
export type DocumentationPhaseCountOutputType = {
|
|
864
|
+
steps: number;
|
|
865
|
+
};
|
|
866
|
+
export type DocumentationPhaseCountOutputTypeSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
867
|
+
steps?: boolean | DocumentationPhaseCountOutputTypeCountStepsArgs;
|
|
868
|
+
};
|
|
869
|
+
/**
|
|
870
|
+
* DocumentationPhaseCountOutputType without action
|
|
871
|
+
*/
|
|
872
|
+
export type DocumentationPhaseCountOutputTypeDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
873
|
+
/**
|
|
874
|
+
* Select specific fields to fetch from the DocumentationPhaseCountOutputType
|
|
875
|
+
*/
|
|
876
|
+
select?: Prisma.DocumentationPhaseCountOutputTypeSelect<ExtArgs> | null;
|
|
877
|
+
};
|
|
878
|
+
/**
|
|
879
|
+
* DocumentationPhaseCountOutputType without action
|
|
880
|
+
*/
|
|
881
|
+
export type DocumentationPhaseCountOutputTypeCountStepsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
882
|
+
where?: Prisma.DocumentationStepWhereInput;
|
|
883
|
+
};
|
|
884
|
+
export type DocumentationPhaseSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
|
|
885
|
+
id?: boolean;
|
|
886
|
+
phaseId?: boolean;
|
|
887
|
+
currentStepId?: boolean;
|
|
888
|
+
approvedDocumentsCount?: boolean;
|
|
889
|
+
requiredDocumentsCount?: boolean;
|
|
890
|
+
completedStepsCount?: boolean;
|
|
891
|
+
totalStepsCount?: boolean;
|
|
892
|
+
minimumCompletionPercentage?: boolean;
|
|
893
|
+
completionCriterion?: boolean;
|
|
894
|
+
stepDefinitionsSnapshot?: boolean;
|
|
895
|
+
requiredDocumentSnapshot?: boolean;
|
|
896
|
+
createdAt?: boolean;
|
|
897
|
+
updatedAt?: boolean;
|
|
898
|
+
phase?: boolean | Prisma.ContractPhaseDefaultArgs<ExtArgs>;
|
|
899
|
+
currentStep?: boolean | Prisma.DocumentationPhase$currentStepArgs<ExtArgs>;
|
|
900
|
+
steps?: boolean | Prisma.DocumentationPhase$stepsArgs<ExtArgs>;
|
|
901
|
+
_count?: boolean | Prisma.DocumentationPhaseCountOutputTypeDefaultArgs<ExtArgs>;
|
|
902
|
+
}, ExtArgs["result"]["documentationPhase"]>;
|
|
903
|
+
export type DocumentationPhaseSelectScalar = {
|
|
904
|
+
id?: boolean;
|
|
905
|
+
phaseId?: boolean;
|
|
906
|
+
currentStepId?: boolean;
|
|
907
|
+
approvedDocumentsCount?: boolean;
|
|
908
|
+
requiredDocumentsCount?: boolean;
|
|
909
|
+
completedStepsCount?: boolean;
|
|
910
|
+
totalStepsCount?: boolean;
|
|
911
|
+
minimumCompletionPercentage?: boolean;
|
|
912
|
+
completionCriterion?: boolean;
|
|
913
|
+
stepDefinitionsSnapshot?: boolean;
|
|
914
|
+
requiredDocumentSnapshot?: boolean;
|
|
915
|
+
createdAt?: boolean;
|
|
916
|
+
updatedAt?: boolean;
|
|
917
|
+
};
|
|
918
|
+
export type DocumentationPhaseOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "phaseId" | "currentStepId" | "approvedDocumentsCount" | "requiredDocumentsCount" | "completedStepsCount" | "totalStepsCount" | "minimumCompletionPercentage" | "completionCriterion" | "stepDefinitionsSnapshot" | "requiredDocumentSnapshot" | "createdAt" | "updatedAt", ExtArgs["result"]["documentationPhase"]>;
|
|
919
|
+
export type DocumentationPhaseInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
920
|
+
phase?: boolean | Prisma.ContractPhaseDefaultArgs<ExtArgs>;
|
|
921
|
+
currentStep?: boolean | Prisma.DocumentationPhase$currentStepArgs<ExtArgs>;
|
|
922
|
+
steps?: boolean | Prisma.DocumentationPhase$stepsArgs<ExtArgs>;
|
|
923
|
+
_count?: boolean | Prisma.DocumentationPhaseCountOutputTypeDefaultArgs<ExtArgs>;
|
|
924
|
+
};
|
|
925
|
+
export type $DocumentationPhasePayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
926
|
+
name: "DocumentationPhase";
|
|
927
|
+
objects: {
|
|
928
|
+
phase: Prisma.$ContractPhasePayload<ExtArgs>;
|
|
929
|
+
currentStep: Prisma.$DocumentationStepPayload<ExtArgs> | null;
|
|
930
|
+
steps: Prisma.$DocumentationStepPayload<ExtArgs>[];
|
|
931
|
+
};
|
|
932
|
+
scalars: runtime.Types.Extensions.GetPayloadResult<{
|
|
933
|
+
id: string;
|
|
934
|
+
phaseId: string;
|
|
935
|
+
currentStepId: string | null;
|
|
936
|
+
approvedDocumentsCount: number;
|
|
937
|
+
requiredDocumentsCount: number;
|
|
938
|
+
completedStepsCount: number;
|
|
939
|
+
totalStepsCount: number;
|
|
940
|
+
minimumCompletionPercentage: number | null;
|
|
941
|
+
completionCriterion: $Enums.CompletionCriterion | null;
|
|
942
|
+
stepDefinitionsSnapshot: runtime.JsonValue | null;
|
|
943
|
+
requiredDocumentSnapshot: runtime.JsonValue | null;
|
|
944
|
+
createdAt: Date;
|
|
945
|
+
updatedAt: Date;
|
|
946
|
+
}, ExtArgs["result"]["documentationPhase"]>;
|
|
947
|
+
composites: {};
|
|
948
|
+
};
|
|
949
|
+
export type DocumentationPhaseGetPayload<S extends boolean | null | undefined | DocumentationPhaseDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$DocumentationPhasePayload, S>;
|
|
950
|
+
export type DocumentationPhaseCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = Omit<DocumentationPhaseFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
951
|
+
select?: DocumentationPhaseCountAggregateInputType | true;
|
|
952
|
+
};
|
|
953
|
+
export interface DocumentationPhaseDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
954
|
+
[K: symbol]: {
|
|
955
|
+
types: Prisma.TypeMap<ExtArgs>['model']['DocumentationPhase'];
|
|
956
|
+
meta: {
|
|
957
|
+
name: 'DocumentationPhase';
|
|
958
|
+
};
|
|
959
|
+
};
|
|
960
|
+
/**
|
|
961
|
+
* Find zero or one DocumentationPhase that matches the filter.
|
|
962
|
+
* @param {DocumentationPhaseFindUniqueArgs} args - Arguments to find a DocumentationPhase
|
|
963
|
+
* @example
|
|
964
|
+
* // Get one DocumentationPhase
|
|
965
|
+
* const documentationPhase = await prisma.documentationPhase.findUnique({
|
|
966
|
+
* where: {
|
|
967
|
+
* // ... provide filter here
|
|
968
|
+
* }
|
|
969
|
+
* })
|
|
970
|
+
*/
|
|
971
|
+
findUnique<T extends DocumentationPhaseFindUniqueArgs>(args: Prisma.SelectSubset<T, DocumentationPhaseFindUniqueArgs<ExtArgs>>): Prisma.Prisma__DocumentationPhaseClient<runtime.Types.Result.GetResult<Prisma.$DocumentationPhasePayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>;
|
|
972
|
+
/**
|
|
973
|
+
* Find one DocumentationPhase that matches the filter or throw an error with `error.code='P2025'`
|
|
974
|
+
* if no matches were found.
|
|
975
|
+
* @param {DocumentationPhaseFindUniqueOrThrowArgs} args - Arguments to find a DocumentationPhase
|
|
976
|
+
* @example
|
|
977
|
+
* // Get one DocumentationPhase
|
|
978
|
+
* const documentationPhase = await prisma.documentationPhase.findUniqueOrThrow({
|
|
979
|
+
* where: {
|
|
980
|
+
* // ... provide filter here
|
|
981
|
+
* }
|
|
982
|
+
* })
|
|
983
|
+
*/
|
|
984
|
+
findUniqueOrThrow<T extends DocumentationPhaseFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, DocumentationPhaseFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__DocumentationPhaseClient<runtime.Types.Result.GetResult<Prisma.$DocumentationPhasePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
|
|
985
|
+
/**
|
|
986
|
+
* Find the first DocumentationPhase that matches the filter.
|
|
987
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
988
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
989
|
+
* @param {DocumentationPhaseFindFirstArgs} args - Arguments to find a DocumentationPhase
|
|
990
|
+
* @example
|
|
991
|
+
* // Get one DocumentationPhase
|
|
992
|
+
* const documentationPhase = await prisma.documentationPhase.findFirst({
|
|
993
|
+
* where: {
|
|
994
|
+
* // ... provide filter here
|
|
995
|
+
* }
|
|
996
|
+
* })
|
|
997
|
+
*/
|
|
998
|
+
findFirst<T extends DocumentationPhaseFindFirstArgs>(args?: Prisma.SelectSubset<T, DocumentationPhaseFindFirstArgs<ExtArgs>>): Prisma.Prisma__DocumentationPhaseClient<runtime.Types.Result.GetResult<Prisma.$DocumentationPhasePayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>;
|
|
999
|
+
/**
|
|
1000
|
+
* Find the first DocumentationPhase that matches the filter or
|
|
1001
|
+
* throw `PrismaKnownClientError` with `P2025` code if no matches were found.
|
|
1002
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
1003
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
1004
|
+
* @param {DocumentationPhaseFindFirstOrThrowArgs} args - Arguments to find a DocumentationPhase
|
|
1005
|
+
* @example
|
|
1006
|
+
* // Get one DocumentationPhase
|
|
1007
|
+
* const documentationPhase = await prisma.documentationPhase.findFirstOrThrow({
|
|
1008
|
+
* where: {
|
|
1009
|
+
* // ... provide filter here
|
|
1010
|
+
* }
|
|
1011
|
+
* })
|
|
1012
|
+
*/
|
|
1013
|
+
findFirstOrThrow<T extends DocumentationPhaseFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, DocumentationPhaseFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__DocumentationPhaseClient<runtime.Types.Result.GetResult<Prisma.$DocumentationPhasePayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
|
|
1014
|
+
/**
|
|
1015
|
+
* Find zero or more DocumentationPhases that matches the filter.
|
|
1016
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
1017
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
1018
|
+
* @param {DocumentationPhaseFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
1019
|
+
* @example
|
|
1020
|
+
* // Get all DocumentationPhases
|
|
1021
|
+
* const documentationPhases = await prisma.documentationPhase.findMany()
|
|
1022
|
+
*
|
|
1023
|
+
* // Get first 10 DocumentationPhases
|
|
1024
|
+
* const documentationPhases = await prisma.documentationPhase.findMany({ take: 10 })
|
|
1025
|
+
*
|
|
1026
|
+
* // Only select the `id`
|
|
1027
|
+
* const documentationPhaseWithIdOnly = await prisma.documentationPhase.findMany({ select: { id: true } })
|
|
1028
|
+
*
|
|
1029
|
+
*/
|
|
1030
|
+
findMany<T extends DocumentationPhaseFindManyArgs>(args?: Prisma.SelectSubset<T, DocumentationPhaseFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$DocumentationPhasePayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>;
|
|
1031
|
+
/**
|
|
1032
|
+
* Create a DocumentationPhase.
|
|
1033
|
+
* @param {DocumentationPhaseCreateArgs} args - Arguments to create a DocumentationPhase.
|
|
1034
|
+
* @example
|
|
1035
|
+
* // Create one DocumentationPhase
|
|
1036
|
+
* const DocumentationPhase = await prisma.documentationPhase.create({
|
|
1037
|
+
* data: {
|
|
1038
|
+
* // ... data to create a DocumentationPhase
|
|
1039
|
+
* }
|
|
1040
|
+
* })
|
|
1041
|
+
*
|
|
1042
|
+
*/
|
|
1043
|
+
create<T extends DocumentationPhaseCreateArgs>(args: Prisma.SelectSubset<T, DocumentationPhaseCreateArgs<ExtArgs>>): Prisma.Prisma__DocumentationPhaseClient<runtime.Types.Result.GetResult<Prisma.$DocumentationPhasePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
|
|
1044
|
+
/**
|
|
1045
|
+
* Create many DocumentationPhases.
|
|
1046
|
+
* @param {DocumentationPhaseCreateManyArgs} args - Arguments to create many DocumentationPhases.
|
|
1047
|
+
* @example
|
|
1048
|
+
* // Create many DocumentationPhases
|
|
1049
|
+
* const documentationPhase = await prisma.documentationPhase.createMany({
|
|
1050
|
+
* data: [
|
|
1051
|
+
* // ... provide data here
|
|
1052
|
+
* ]
|
|
1053
|
+
* })
|
|
1054
|
+
*
|
|
1055
|
+
*/
|
|
1056
|
+
createMany<T extends DocumentationPhaseCreateManyArgs>(args?: Prisma.SelectSubset<T, DocumentationPhaseCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>;
|
|
1057
|
+
/**
|
|
1058
|
+
* Delete a DocumentationPhase.
|
|
1059
|
+
* @param {DocumentationPhaseDeleteArgs} args - Arguments to delete one DocumentationPhase.
|
|
1060
|
+
* @example
|
|
1061
|
+
* // Delete one DocumentationPhase
|
|
1062
|
+
* const DocumentationPhase = await prisma.documentationPhase.delete({
|
|
1063
|
+
* where: {
|
|
1064
|
+
* // ... filter to delete one DocumentationPhase
|
|
1065
|
+
* }
|
|
1066
|
+
* })
|
|
1067
|
+
*
|
|
1068
|
+
*/
|
|
1069
|
+
delete<T extends DocumentationPhaseDeleteArgs>(args: Prisma.SelectSubset<T, DocumentationPhaseDeleteArgs<ExtArgs>>): Prisma.Prisma__DocumentationPhaseClient<runtime.Types.Result.GetResult<Prisma.$DocumentationPhasePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
|
|
1070
|
+
/**
|
|
1071
|
+
* Update one DocumentationPhase.
|
|
1072
|
+
* @param {DocumentationPhaseUpdateArgs} args - Arguments to update one DocumentationPhase.
|
|
1073
|
+
* @example
|
|
1074
|
+
* // Update one DocumentationPhase
|
|
1075
|
+
* const documentationPhase = await prisma.documentationPhase.update({
|
|
1076
|
+
* where: {
|
|
1077
|
+
* // ... provide filter here
|
|
1078
|
+
* },
|
|
1079
|
+
* data: {
|
|
1080
|
+
* // ... provide data here
|
|
1081
|
+
* }
|
|
1082
|
+
* })
|
|
1083
|
+
*
|
|
1084
|
+
*/
|
|
1085
|
+
update<T extends DocumentationPhaseUpdateArgs>(args: Prisma.SelectSubset<T, DocumentationPhaseUpdateArgs<ExtArgs>>): Prisma.Prisma__DocumentationPhaseClient<runtime.Types.Result.GetResult<Prisma.$DocumentationPhasePayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
|
|
1086
|
+
/**
|
|
1087
|
+
* Delete zero or more DocumentationPhases.
|
|
1088
|
+
* @param {DocumentationPhaseDeleteManyArgs} args - Arguments to filter DocumentationPhases to delete.
|
|
1089
|
+
* @example
|
|
1090
|
+
* // Delete a few DocumentationPhases
|
|
1091
|
+
* const { count } = await prisma.documentationPhase.deleteMany({
|
|
1092
|
+
* where: {
|
|
1093
|
+
* // ... provide filter here
|
|
1094
|
+
* }
|
|
1095
|
+
* })
|
|
1096
|
+
*
|
|
1097
|
+
*/
|
|
1098
|
+
deleteMany<T extends DocumentationPhaseDeleteManyArgs>(args?: Prisma.SelectSubset<T, DocumentationPhaseDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>;
|
|
1099
|
+
/**
|
|
1100
|
+
* Update zero or more DocumentationPhases.
|
|
1101
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
1102
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
1103
|
+
* @param {DocumentationPhaseUpdateManyArgs} args - Arguments to update one or more rows.
|
|
1104
|
+
* @example
|
|
1105
|
+
* // Update many DocumentationPhases
|
|
1106
|
+
* const documentationPhase = await prisma.documentationPhase.updateMany({
|
|
1107
|
+
* where: {
|
|
1108
|
+
* // ... provide filter here
|
|
1109
|
+
* },
|
|
1110
|
+
* data: {
|
|
1111
|
+
* // ... provide data here
|
|
1112
|
+
* }
|
|
1113
|
+
* })
|
|
1114
|
+
*
|
|
1115
|
+
*/
|
|
1116
|
+
updateMany<T extends DocumentationPhaseUpdateManyArgs>(args: Prisma.SelectSubset<T, DocumentationPhaseUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>;
|
|
1117
|
+
/**
|
|
1118
|
+
* Create or update one DocumentationPhase.
|
|
1119
|
+
* @param {DocumentationPhaseUpsertArgs} args - Arguments to update or create a DocumentationPhase.
|
|
1120
|
+
* @example
|
|
1121
|
+
* // Update or create a DocumentationPhase
|
|
1122
|
+
* const documentationPhase = await prisma.documentationPhase.upsert({
|
|
1123
|
+
* create: {
|
|
1124
|
+
* // ... data to create a DocumentationPhase
|
|
1125
|
+
* },
|
|
1126
|
+
* update: {
|
|
1127
|
+
* // ... in case it already exists, update
|
|
1128
|
+
* },
|
|
1129
|
+
* where: {
|
|
1130
|
+
* // ... the filter for the DocumentationPhase we want to update
|
|
1131
|
+
* }
|
|
1132
|
+
* })
|
|
1133
|
+
*/
|
|
1134
|
+
upsert<T extends DocumentationPhaseUpsertArgs>(args: Prisma.SelectSubset<T, DocumentationPhaseUpsertArgs<ExtArgs>>): Prisma.Prisma__DocumentationPhaseClient<runtime.Types.Result.GetResult<Prisma.$DocumentationPhasePayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
|
|
1135
|
+
/**
|
|
1136
|
+
* Count the number of DocumentationPhases.
|
|
1137
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
1138
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
1139
|
+
* @param {DocumentationPhaseCountArgs} args - Arguments to filter DocumentationPhases to count.
|
|
1140
|
+
* @example
|
|
1141
|
+
* // Count the number of DocumentationPhases
|
|
1142
|
+
* const count = await prisma.documentationPhase.count({
|
|
1143
|
+
* where: {
|
|
1144
|
+
* // ... the filter for the DocumentationPhases we want to count
|
|
1145
|
+
* }
|
|
1146
|
+
* })
|
|
1147
|
+
**/
|
|
1148
|
+
count<T extends DocumentationPhaseCountArgs>(args?: Prisma.Subset<T, DocumentationPhaseCountArgs>): Prisma.PrismaPromise<T extends runtime.Types.Utils.Record<'select', any> ? T['select'] extends true ? number : Prisma.GetScalarType<T['select'], DocumentationPhaseCountAggregateOutputType> : number>;
|
|
1149
|
+
/**
|
|
1150
|
+
* Allows you to perform aggregations operations on a DocumentationPhase.
|
|
1151
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
1152
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
1153
|
+
* @param {DocumentationPhaseAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
|
|
1154
|
+
* @example
|
|
1155
|
+
* // Ordered by age ascending
|
|
1156
|
+
* // Where email contains prisma.io
|
|
1157
|
+
* // Limited to the 10 users
|
|
1158
|
+
* const aggregations = await prisma.user.aggregate({
|
|
1159
|
+
* _avg: {
|
|
1160
|
+
* age: true,
|
|
1161
|
+
* },
|
|
1162
|
+
* where: {
|
|
1163
|
+
* email: {
|
|
1164
|
+
* contains: "prisma.io",
|
|
1165
|
+
* },
|
|
1166
|
+
* },
|
|
1167
|
+
* orderBy: {
|
|
1168
|
+
* age: "asc",
|
|
1169
|
+
* },
|
|
1170
|
+
* take: 10,
|
|
1171
|
+
* })
|
|
1172
|
+
**/
|
|
1173
|
+
aggregate<T extends DocumentationPhaseAggregateArgs>(args: Prisma.Subset<T, DocumentationPhaseAggregateArgs>): Prisma.PrismaPromise<GetDocumentationPhaseAggregateType<T>>;
|
|
1174
|
+
/**
|
|
1175
|
+
* Group by DocumentationPhase.
|
|
1176
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
1177
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
1178
|
+
* @param {DocumentationPhaseGroupByArgs} args - Group by arguments.
|
|
1179
|
+
* @example
|
|
1180
|
+
* // Group by city, order by createdAt, get count
|
|
1181
|
+
* const result = await prisma.user.groupBy({
|
|
1182
|
+
* by: ['city', 'createdAt'],
|
|
1183
|
+
* orderBy: {
|
|
1184
|
+
* createdAt: true
|
|
1185
|
+
* },
|
|
1186
|
+
* _count: {
|
|
1187
|
+
* _all: true
|
|
1188
|
+
* },
|
|
1189
|
+
* })
|
|
1190
|
+
*
|
|
1191
|
+
**/
|
|
1192
|
+
groupBy<T extends DocumentationPhaseGroupByArgs, HasSelectOrTake extends Prisma.Or<Prisma.Extends<'skip', Prisma.Keys<T>>, Prisma.Extends<'take', Prisma.Keys<T>>>, OrderByArg extends Prisma.True extends HasSelectOrTake ? {
|
|
1193
|
+
orderBy: DocumentationPhaseGroupByArgs['orderBy'];
|
|
1194
|
+
} : {
|
|
1195
|
+
orderBy?: DocumentationPhaseGroupByArgs['orderBy'];
|
|
1196
|
+
}, OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>, ByFields extends Prisma.MaybeTupleToUnion<T['by']>, ByValid extends Prisma.Has<ByFields, OrderFields>, HavingFields extends Prisma.GetHavingFields<T['having']>, HavingValid extends Prisma.Has<ByFields, HavingFields>, ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False, InputErrors extends ByEmpty extends Prisma.True ? `Error: "by" must not be empty.` : HavingValid extends Prisma.False ? {
|
|
1197
|
+
[P in HavingFields]: P extends ByFields ? never : P extends string ? `Error: Field "${P}" used in "having" needs to be provided in "by".` : [
|
|
1198
|
+
Error,
|
|
1199
|
+
'Field ',
|
|
1200
|
+
P,
|
|
1201
|
+
` in "having" needs to be provided in "by"`
|
|
1202
|
+
];
|
|
1203
|
+
}[HavingFields] : 'take' extends Prisma.Keys<T> ? 'orderBy' extends Prisma.Keys<T> ? ByValid extends Prisma.True ? {} : {
|
|
1204
|
+
[P in OrderFields]: P extends ByFields ? never : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`;
|
|
1205
|
+
}[OrderFields] : 'Error: If you provide "take", you also need to provide "orderBy"' : 'skip' extends Prisma.Keys<T> ? 'orderBy' extends Prisma.Keys<T> ? ByValid extends Prisma.True ? {} : {
|
|
1206
|
+
[P in OrderFields]: P extends ByFields ? never : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`;
|
|
1207
|
+
}[OrderFields] : 'Error: If you provide "skip", you also need to provide "orderBy"' : ByValid extends Prisma.True ? {} : {
|
|
1208
|
+
[P in OrderFields]: P extends ByFields ? never : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`;
|
|
1209
|
+
}[OrderFields]>(args: Prisma.SubsetIntersection<T, DocumentationPhaseGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetDocumentationPhaseGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>;
|
|
1210
|
+
/**
|
|
1211
|
+
* Fields of the DocumentationPhase model
|
|
1212
|
+
*/
|
|
1213
|
+
readonly fields: DocumentationPhaseFieldRefs;
|
|
1214
|
+
}
|
|
1215
|
+
/**
|
|
1216
|
+
* The delegate class that acts as a "Promise-like" for DocumentationPhase.
|
|
1217
|
+
* Why is this prefixed with `Prisma__`?
|
|
1218
|
+
* Because we want to prevent naming conflicts as mentioned in
|
|
1219
|
+
* https://github.com/prisma/prisma-client-js/issues/707
|
|
1220
|
+
*/
|
|
1221
|
+
export interface Prisma__DocumentationPhaseClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
1222
|
+
readonly [Symbol.toStringTag]: "PrismaPromise";
|
|
1223
|
+
phase<T extends Prisma.ContractPhaseDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.ContractPhaseDefaultArgs<ExtArgs>>): Prisma.Prisma__ContractPhaseClient<runtime.Types.Result.GetResult<Prisma.$ContractPhasePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>;
|
|
1224
|
+
currentStep<T extends Prisma.DocumentationPhase$currentStepArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.DocumentationPhase$currentStepArgs<ExtArgs>>): Prisma.Prisma__DocumentationStepClient<runtime.Types.Result.GetResult<Prisma.$DocumentationStepPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>;
|
|
1225
|
+
steps<T extends Prisma.DocumentationPhase$stepsArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.DocumentationPhase$stepsArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$DocumentationStepPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>;
|
|
1226
|
+
/**
|
|
1227
|
+
* Attaches callbacks for the resolution and/or rejection of the Promise.
|
|
1228
|
+
* @param onfulfilled The callback to execute when the Promise is resolved.
|
|
1229
|
+
* @param onrejected The callback to execute when the Promise is rejected.
|
|
1230
|
+
* @returns A Promise for the completion of which ever callback is executed.
|
|
1231
|
+
*/
|
|
1232
|
+
then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2>;
|
|
1233
|
+
/**
|
|
1234
|
+
* Attaches a callback for only the rejection of the Promise.
|
|
1235
|
+
* @param onrejected The callback to execute when the Promise is rejected.
|
|
1236
|
+
* @returns A Promise for the completion of the callback.
|
|
1237
|
+
*/
|
|
1238
|
+
catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>;
|
|
1239
|
+
/**
|
|
1240
|
+
* Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
|
|
1241
|
+
* resolved value cannot be modified from the callback.
|
|
1242
|
+
* @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
|
|
1243
|
+
* @returns A Promise for the completion of the callback.
|
|
1244
|
+
*/
|
|
1245
|
+
finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>;
|
|
1246
|
+
}
|
|
1247
|
+
/**
|
|
1248
|
+
* Fields of the DocumentationPhase model
|
|
1249
|
+
*/
|
|
1250
|
+
export interface DocumentationPhaseFieldRefs {
|
|
1251
|
+
readonly id: Prisma.FieldRef<"DocumentationPhase", 'String'>;
|
|
1252
|
+
readonly phaseId: Prisma.FieldRef<"DocumentationPhase", 'String'>;
|
|
1253
|
+
readonly currentStepId: Prisma.FieldRef<"DocumentationPhase", 'String'>;
|
|
1254
|
+
readonly approvedDocumentsCount: Prisma.FieldRef<"DocumentationPhase", 'Int'>;
|
|
1255
|
+
readonly requiredDocumentsCount: Prisma.FieldRef<"DocumentationPhase", 'Int'>;
|
|
1256
|
+
readonly completedStepsCount: Prisma.FieldRef<"DocumentationPhase", 'Int'>;
|
|
1257
|
+
readonly totalStepsCount: Prisma.FieldRef<"DocumentationPhase", 'Int'>;
|
|
1258
|
+
readonly minimumCompletionPercentage: Prisma.FieldRef<"DocumentationPhase", 'Float'>;
|
|
1259
|
+
readonly completionCriterion: Prisma.FieldRef<"DocumentationPhase", 'CompletionCriterion'>;
|
|
1260
|
+
readonly stepDefinitionsSnapshot: Prisma.FieldRef<"DocumentationPhase", 'Json'>;
|
|
1261
|
+
readonly requiredDocumentSnapshot: Prisma.FieldRef<"DocumentationPhase", 'Json'>;
|
|
1262
|
+
readonly createdAt: Prisma.FieldRef<"DocumentationPhase", 'DateTime'>;
|
|
1263
|
+
readonly updatedAt: Prisma.FieldRef<"DocumentationPhase", 'DateTime'>;
|
|
1264
|
+
}
|
|
1265
|
+
/**
|
|
1266
|
+
* DocumentationPhase findUnique
|
|
1267
|
+
*/
|
|
1268
|
+
export type DocumentationPhaseFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1269
|
+
/**
|
|
1270
|
+
* Select specific fields to fetch from the DocumentationPhase
|
|
1271
|
+
*/
|
|
1272
|
+
select?: Prisma.DocumentationPhaseSelect<ExtArgs> | null;
|
|
1273
|
+
/**
|
|
1274
|
+
* Omit specific fields from the DocumentationPhase
|
|
1275
|
+
*/
|
|
1276
|
+
omit?: Prisma.DocumentationPhaseOmit<ExtArgs> | null;
|
|
1277
|
+
/**
|
|
1278
|
+
* Choose, which related nodes to fetch as well
|
|
1279
|
+
*/
|
|
1280
|
+
include?: Prisma.DocumentationPhaseInclude<ExtArgs> | null;
|
|
1281
|
+
/**
|
|
1282
|
+
* Filter, which DocumentationPhase to fetch.
|
|
1283
|
+
*/
|
|
1284
|
+
where: Prisma.DocumentationPhaseWhereUniqueInput;
|
|
1285
|
+
};
|
|
1286
|
+
/**
|
|
1287
|
+
* DocumentationPhase findUniqueOrThrow
|
|
1288
|
+
*/
|
|
1289
|
+
export type DocumentationPhaseFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1290
|
+
/**
|
|
1291
|
+
* Select specific fields to fetch from the DocumentationPhase
|
|
1292
|
+
*/
|
|
1293
|
+
select?: Prisma.DocumentationPhaseSelect<ExtArgs> | null;
|
|
1294
|
+
/**
|
|
1295
|
+
* Omit specific fields from the DocumentationPhase
|
|
1296
|
+
*/
|
|
1297
|
+
omit?: Prisma.DocumentationPhaseOmit<ExtArgs> | null;
|
|
1298
|
+
/**
|
|
1299
|
+
* Choose, which related nodes to fetch as well
|
|
1300
|
+
*/
|
|
1301
|
+
include?: Prisma.DocumentationPhaseInclude<ExtArgs> | null;
|
|
1302
|
+
/**
|
|
1303
|
+
* Filter, which DocumentationPhase to fetch.
|
|
1304
|
+
*/
|
|
1305
|
+
where: Prisma.DocumentationPhaseWhereUniqueInput;
|
|
1306
|
+
};
|
|
1307
|
+
/**
|
|
1308
|
+
* DocumentationPhase findFirst
|
|
1309
|
+
*/
|
|
1310
|
+
export type DocumentationPhaseFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1311
|
+
/**
|
|
1312
|
+
* Select specific fields to fetch from the DocumentationPhase
|
|
1313
|
+
*/
|
|
1314
|
+
select?: Prisma.DocumentationPhaseSelect<ExtArgs> | null;
|
|
1315
|
+
/**
|
|
1316
|
+
* Omit specific fields from the DocumentationPhase
|
|
1317
|
+
*/
|
|
1318
|
+
omit?: Prisma.DocumentationPhaseOmit<ExtArgs> | null;
|
|
1319
|
+
/**
|
|
1320
|
+
* Choose, which related nodes to fetch as well
|
|
1321
|
+
*/
|
|
1322
|
+
include?: Prisma.DocumentationPhaseInclude<ExtArgs> | null;
|
|
1323
|
+
/**
|
|
1324
|
+
* Filter, which DocumentationPhase to fetch.
|
|
1325
|
+
*/
|
|
1326
|
+
where?: Prisma.DocumentationPhaseWhereInput;
|
|
1327
|
+
/**
|
|
1328
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
1329
|
+
*
|
|
1330
|
+
* Determine the order of DocumentationPhases to fetch.
|
|
1331
|
+
*/
|
|
1332
|
+
orderBy?: Prisma.DocumentationPhaseOrderByWithRelationInput | Prisma.DocumentationPhaseOrderByWithRelationInput[];
|
|
1333
|
+
/**
|
|
1334
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
1335
|
+
*
|
|
1336
|
+
* Sets the position for searching for DocumentationPhases.
|
|
1337
|
+
*/
|
|
1338
|
+
cursor?: Prisma.DocumentationPhaseWhereUniqueInput;
|
|
1339
|
+
/**
|
|
1340
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
1341
|
+
*
|
|
1342
|
+
* Take `±n` DocumentationPhases from the position of the cursor.
|
|
1343
|
+
*/
|
|
1344
|
+
take?: number;
|
|
1345
|
+
/**
|
|
1346
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
1347
|
+
*
|
|
1348
|
+
* Skip the first `n` DocumentationPhases.
|
|
1349
|
+
*/
|
|
1350
|
+
skip?: number;
|
|
1351
|
+
/**
|
|
1352
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
1353
|
+
*
|
|
1354
|
+
* Filter by unique combinations of DocumentationPhases.
|
|
1355
|
+
*/
|
|
1356
|
+
distinct?: Prisma.DocumentationPhaseScalarFieldEnum | Prisma.DocumentationPhaseScalarFieldEnum[];
|
|
1357
|
+
};
|
|
1358
|
+
/**
|
|
1359
|
+
* DocumentationPhase findFirstOrThrow
|
|
1360
|
+
*/
|
|
1361
|
+
export type DocumentationPhaseFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1362
|
+
/**
|
|
1363
|
+
* Select specific fields to fetch from the DocumentationPhase
|
|
1364
|
+
*/
|
|
1365
|
+
select?: Prisma.DocumentationPhaseSelect<ExtArgs> | null;
|
|
1366
|
+
/**
|
|
1367
|
+
* Omit specific fields from the DocumentationPhase
|
|
1368
|
+
*/
|
|
1369
|
+
omit?: Prisma.DocumentationPhaseOmit<ExtArgs> | null;
|
|
1370
|
+
/**
|
|
1371
|
+
* Choose, which related nodes to fetch as well
|
|
1372
|
+
*/
|
|
1373
|
+
include?: Prisma.DocumentationPhaseInclude<ExtArgs> | null;
|
|
1374
|
+
/**
|
|
1375
|
+
* Filter, which DocumentationPhase to fetch.
|
|
1376
|
+
*/
|
|
1377
|
+
where?: Prisma.DocumentationPhaseWhereInput;
|
|
1378
|
+
/**
|
|
1379
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
1380
|
+
*
|
|
1381
|
+
* Determine the order of DocumentationPhases to fetch.
|
|
1382
|
+
*/
|
|
1383
|
+
orderBy?: Prisma.DocumentationPhaseOrderByWithRelationInput | Prisma.DocumentationPhaseOrderByWithRelationInput[];
|
|
1384
|
+
/**
|
|
1385
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
1386
|
+
*
|
|
1387
|
+
* Sets the position for searching for DocumentationPhases.
|
|
1388
|
+
*/
|
|
1389
|
+
cursor?: Prisma.DocumentationPhaseWhereUniqueInput;
|
|
1390
|
+
/**
|
|
1391
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
1392
|
+
*
|
|
1393
|
+
* Take `±n` DocumentationPhases from the position of the cursor.
|
|
1394
|
+
*/
|
|
1395
|
+
take?: number;
|
|
1396
|
+
/**
|
|
1397
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
1398
|
+
*
|
|
1399
|
+
* Skip the first `n` DocumentationPhases.
|
|
1400
|
+
*/
|
|
1401
|
+
skip?: number;
|
|
1402
|
+
/**
|
|
1403
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
1404
|
+
*
|
|
1405
|
+
* Filter by unique combinations of DocumentationPhases.
|
|
1406
|
+
*/
|
|
1407
|
+
distinct?: Prisma.DocumentationPhaseScalarFieldEnum | Prisma.DocumentationPhaseScalarFieldEnum[];
|
|
1408
|
+
};
|
|
1409
|
+
/**
|
|
1410
|
+
* DocumentationPhase findMany
|
|
1411
|
+
*/
|
|
1412
|
+
export type DocumentationPhaseFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1413
|
+
/**
|
|
1414
|
+
* Select specific fields to fetch from the DocumentationPhase
|
|
1415
|
+
*/
|
|
1416
|
+
select?: Prisma.DocumentationPhaseSelect<ExtArgs> | null;
|
|
1417
|
+
/**
|
|
1418
|
+
* Omit specific fields from the DocumentationPhase
|
|
1419
|
+
*/
|
|
1420
|
+
omit?: Prisma.DocumentationPhaseOmit<ExtArgs> | null;
|
|
1421
|
+
/**
|
|
1422
|
+
* Choose, which related nodes to fetch as well
|
|
1423
|
+
*/
|
|
1424
|
+
include?: Prisma.DocumentationPhaseInclude<ExtArgs> | null;
|
|
1425
|
+
/**
|
|
1426
|
+
* Filter, which DocumentationPhases to fetch.
|
|
1427
|
+
*/
|
|
1428
|
+
where?: Prisma.DocumentationPhaseWhereInput;
|
|
1429
|
+
/**
|
|
1430
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
1431
|
+
*
|
|
1432
|
+
* Determine the order of DocumentationPhases to fetch.
|
|
1433
|
+
*/
|
|
1434
|
+
orderBy?: Prisma.DocumentationPhaseOrderByWithRelationInput | Prisma.DocumentationPhaseOrderByWithRelationInput[];
|
|
1435
|
+
/**
|
|
1436
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
1437
|
+
*
|
|
1438
|
+
* Sets the position for listing DocumentationPhases.
|
|
1439
|
+
*/
|
|
1440
|
+
cursor?: Prisma.DocumentationPhaseWhereUniqueInput;
|
|
1441
|
+
/**
|
|
1442
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
1443
|
+
*
|
|
1444
|
+
* Take `±n` DocumentationPhases from the position of the cursor.
|
|
1445
|
+
*/
|
|
1446
|
+
take?: number;
|
|
1447
|
+
/**
|
|
1448
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
1449
|
+
*
|
|
1450
|
+
* Skip the first `n` DocumentationPhases.
|
|
1451
|
+
*/
|
|
1452
|
+
skip?: number;
|
|
1453
|
+
distinct?: Prisma.DocumentationPhaseScalarFieldEnum | Prisma.DocumentationPhaseScalarFieldEnum[];
|
|
1454
|
+
};
|
|
1455
|
+
/**
|
|
1456
|
+
* DocumentationPhase create
|
|
1457
|
+
*/
|
|
1458
|
+
export type DocumentationPhaseCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1459
|
+
/**
|
|
1460
|
+
* Select specific fields to fetch from the DocumentationPhase
|
|
1461
|
+
*/
|
|
1462
|
+
select?: Prisma.DocumentationPhaseSelect<ExtArgs> | null;
|
|
1463
|
+
/**
|
|
1464
|
+
* Omit specific fields from the DocumentationPhase
|
|
1465
|
+
*/
|
|
1466
|
+
omit?: Prisma.DocumentationPhaseOmit<ExtArgs> | null;
|
|
1467
|
+
/**
|
|
1468
|
+
* Choose, which related nodes to fetch as well
|
|
1469
|
+
*/
|
|
1470
|
+
include?: Prisma.DocumentationPhaseInclude<ExtArgs> | null;
|
|
1471
|
+
/**
|
|
1472
|
+
* The data needed to create a DocumentationPhase.
|
|
1473
|
+
*/
|
|
1474
|
+
data: Prisma.XOR<Prisma.DocumentationPhaseCreateInput, Prisma.DocumentationPhaseUncheckedCreateInput>;
|
|
1475
|
+
};
|
|
1476
|
+
/**
|
|
1477
|
+
* DocumentationPhase createMany
|
|
1478
|
+
*/
|
|
1479
|
+
export type DocumentationPhaseCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1480
|
+
/**
|
|
1481
|
+
* The data used to create many DocumentationPhases.
|
|
1482
|
+
*/
|
|
1483
|
+
data: Prisma.DocumentationPhaseCreateManyInput | Prisma.DocumentationPhaseCreateManyInput[];
|
|
1484
|
+
skipDuplicates?: boolean;
|
|
1485
|
+
};
|
|
1486
|
+
/**
|
|
1487
|
+
* DocumentationPhase update
|
|
1488
|
+
*/
|
|
1489
|
+
export type DocumentationPhaseUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1490
|
+
/**
|
|
1491
|
+
* Select specific fields to fetch from the DocumentationPhase
|
|
1492
|
+
*/
|
|
1493
|
+
select?: Prisma.DocumentationPhaseSelect<ExtArgs> | null;
|
|
1494
|
+
/**
|
|
1495
|
+
* Omit specific fields from the DocumentationPhase
|
|
1496
|
+
*/
|
|
1497
|
+
omit?: Prisma.DocumentationPhaseOmit<ExtArgs> | null;
|
|
1498
|
+
/**
|
|
1499
|
+
* Choose, which related nodes to fetch as well
|
|
1500
|
+
*/
|
|
1501
|
+
include?: Prisma.DocumentationPhaseInclude<ExtArgs> | null;
|
|
1502
|
+
/**
|
|
1503
|
+
* The data needed to update a DocumentationPhase.
|
|
1504
|
+
*/
|
|
1505
|
+
data: Prisma.XOR<Prisma.DocumentationPhaseUpdateInput, Prisma.DocumentationPhaseUncheckedUpdateInput>;
|
|
1506
|
+
/**
|
|
1507
|
+
* Choose, which DocumentationPhase to update.
|
|
1508
|
+
*/
|
|
1509
|
+
where: Prisma.DocumentationPhaseWhereUniqueInput;
|
|
1510
|
+
};
|
|
1511
|
+
/**
|
|
1512
|
+
* DocumentationPhase updateMany
|
|
1513
|
+
*/
|
|
1514
|
+
export type DocumentationPhaseUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1515
|
+
/**
|
|
1516
|
+
* The data used to update DocumentationPhases.
|
|
1517
|
+
*/
|
|
1518
|
+
data: Prisma.XOR<Prisma.DocumentationPhaseUpdateManyMutationInput, Prisma.DocumentationPhaseUncheckedUpdateManyInput>;
|
|
1519
|
+
/**
|
|
1520
|
+
* Filter which DocumentationPhases to update
|
|
1521
|
+
*/
|
|
1522
|
+
where?: Prisma.DocumentationPhaseWhereInput;
|
|
1523
|
+
/**
|
|
1524
|
+
* Limit how many DocumentationPhases to update.
|
|
1525
|
+
*/
|
|
1526
|
+
limit?: number;
|
|
1527
|
+
};
|
|
1528
|
+
/**
|
|
1529
|
+
* DocumentationPhase upsert
|
|
1530
|
+
*/
|
|
1531
|
+
export type DocumentationPhaseUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1532
|
+
/**
|
|
1533
|
+
* Select specific fields to fetch from the DocumentationPhase
|
|
1534
|
+
*/
|
|
1535
|
+
select?: Prisma.DocumentationPhaseSelect<ExtArgs> | null;
|
|
1536
|
+
/**
|
|
1537
|
+
* Omit specific fields from the DocumentationPhase
|
|
1538
|
+
*/
|
|
1539
|
+
omit?: Prisma.DocumentationPhaseOmit<ExtArgs> | null;
|
|
1540
|
+
/**
|
|
1541
|
+
* Choose, which related nodes to fetch as well
|
|
1542
|
+
*/
|
|
1543
|
+
include?: Prisma.DocumentationPhaseInclude<ExtArgs> | null;
|
|
1544
|
+
/**
|
|
1545
|
+
* The filter to search for the DocumentationPhase to update in case it exists.
|
|
1546
|
+
*/
|
|
1547
|
+
where: Prisma.DocumentationPhaseWhereUniqueInput;
|
|
1548
|
+
/**
|
|
1549
|
+
* In case the DocumentationPhase found by the `where` argument doesn't exist, create a new DocumentationPhase with this data.
|
|
1550
|
+
*/
|
|
1551
|
+
create: Prisma.XOR<Prisma.DocumentationPhaseCreateInput, Prisma.DocumentationPhaseUncheckedCreateInput>;
|
|
1552
|
+
/**
|
|
1553
|
+
* In case the DocumentationPhase was found with the provided `where` argument, update it with this data.
|
|
1554
|
+
*/
|
|
1555
|
+
update: Prisma.XOR<Prisma.DocumentationPhaseUpdateInput, Prisma.DocumentationPhaseUncheckedUpdateInput>;
|
|
1556
|
+
};
|
|
1557
|
+
/**
|
|
1558
|
+
* DocumentationPhase delete
|
|
1559
|
+
*/
|
|
1560
|
+
export type DocumentationPhaseDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1561
|
+
/**
|
|
1562
|
+
* Select specific fields to fetch from the DocumentationPhase
|
|
1563
|
+
*/
|
|
1564
|
+
select?: Prisma.DocumentationPhaseSelect<ExtArgs> | null;
|
|
1565
|
+
/**
|
|
1566
|
+
* Omit specific fields from the DocumentationPhase
|
|
1567
|
+
*/
|
|
1568
|
+
omit?: Prisma.DocumentationPhaseOmit<ExtArgs> | null;
|
|
1569
|
+
/**
|
|
1570
|
+
* Choose, which related nodes to fetch as well
|
|
1571
|
+
*/
|
|
1572
|
+
include?: Prisma.DocumentationPhaseInclude<ExtArgs> | null;
|
|
1573
|
+
/**
|
|
1574
|
+
* Filter which DocumentationPhase to delete.
|
|
1575
|
+
*/
|
|
1576
|
+
where: Prisma.DocumentationPhaseWhereUniqueInput;
|
|
1577
|
+
};
|
|
1578
|
+
/**
|
|
1579
|
+
* DocumentationPhase deleteMany
|
|
1580
|
+
*/
|
|
1581
|
+
export type DocumentationPhaseDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1582
|
+
/**
|
|
1583
|
+
* Filter which DocumentationPhases to delete
|
|
1584
|
+
*/
|
|
1585
|
+
where?: Prisma.DocumentationPhaseWhereInput;
|
|
1586
|
+
/**
|
|
1587
|
+
* Limit how many DocumentationPhases to delete.
|
|
1588
|
+
*/
|
|
1589
|
+
limit?: number;
|
|
1590
|
+
};
|
|
1591
|
+
/**
|
|
1592
|
+
* DocumentationPhase.currentStep
|
|
1593
|
+
*/
|
|
1594
|
+
export type DocumentationPhase$currentStepArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1595
|
+
/**
|
|
1596
|
+
* Select specific fields to fetch from the DocumentationStep
|
|
1597
|
+
*/
|
|
1598
|
+
select?: Prisma.DocumentationStepSelect<ExtArgs> | null;
|
|
1599
|
+
/**
|
|
1600
|
+
* Omit specific fields from the DocumentationStep
|
|
1601
|
+
*/
|
|
1602
|
+
omit?: Prisma.DocumentationStepOmit<ExtArgs> | null;
|
|
1603
|
+
/**
|
|
1604
|
+
* Choose, which related nodes to fetch as well
|
|
1605
|
+
*/
|
|
1606
|
+
include?: Prisma.DocumentationStepInclude<ExtArgs> | null;
|
|
1607
|
+
where?: Prisma.DocumentationStepWhereInput;
|
|
1608
|
+
};
|
|
1609
|
+
/**
|
|
1610
|
+
* DocumentationPhase.steps
|
|
1611
|
+
*/
|
|
1612
|
+
export type DocumentationPhase$stepsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1613
|
+
/**
|
|
1614
|
+
* Select specific fields to fetch from the DocumentationStep
|
|
1615
|
+
*/
|
|
1616
|
+
select?: Prisma.DocumentationStepSelect<ExtArgs> | null;
|
|
1617
|
+
/**
|
|
1618
|
+
* Omit specific fields from the DocumentationStep
|
|
1619
|
+
*/
|
|
1620
|
+
omit?: Prisma.DocumentationStepOmit<ExtArgs> | null;
|
|
1621
|
+
/**
|
|
1622
|
+
* Choose, which related nodes to fetch as well
|
|
1623
|
+
*/
|
|
1624
|
+
include?: Prisma.DocumentationStepInclude<ExtArgs> | null;
|
|
1625
|
+
where?: Prisma.DocumentationStepWhereInput;
|
|
1626
|
+
orderBy?: Prisma.DocumentationStepOrderByWithRelationInput | Prisma.DocumentationStepOrderByWithRelationInput[];
|
|
1627
|
+
cursor?: Prisma.DocumentationStepWhereUniqueInput;
|
|
1628
|
+
take?: number;
|
|
1629
|
+
skip?: number;
|
|
1630
|
+
distinct?: Prisma.DocumentationStepScalarFieldEnum | Prisma.DocumentationStepScalarFieldEnum[];
|
|
1631
|
+
};
|
|
1632
|
+
/**
|
|
1633
|
+
* DocumentationPhase without action
|
|
1634
|
+
*/
|
|
1635
|
+
export type DocumentationPhaseDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1636
|
+
/**
|
|
1637
|
+
* Select specific fields to fetch from the DocumentationPhase
|
|
1638
|
+
*/
|
|
1639
|
+
select?: Prisma.DocumentationPhaseSelect<ExtArgs> | null;
|
|
1640
|
+
/**
|
|
1641
|
+
* Omit specific fields from the DocumentationPhase
|
|
1642
|
+
*/
|
|
1643
|
+
omit?: Prisma.DocumentationPhaseOmit<ExtArgs> | null;
|
|
1644
|
+
/**
|
|
1645
|
+
* Choose, which related nodes to fetch as well
|
|
1646
|
+
*/
|
|
1647
|
+
include?: Prisma.DocumentationPhaseInclude<ExtArgs> | null;
|
|
1648
|
+
};
|
|
1649
|
+
export {};
|