@aeolus-fleet/trierarch-plugin 0.30.0 → 0.32.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +6 -3
- package/dist/adapters/fleet/core-version.d.ts +12 -3
- package/dist/adapters/fleet/core-version.js +22 -6
- package/dist/adapters/fleet/core-version.js.map +1 -1
- package/dist/adapters/fleet/rest-fleet-door.js +10 -0
- package/dist/adapters/fleet/rest-fleet-door.js.map +1 -1
- package/dist/adapters/prisma/enabled-models.d.ts +4 -0
- package/dist/adapters/prisma/enabled-models.js +14 -0
- package/dist/adapters/prisma/enabled-models.js.map +1 -0
- package/dist/adapters/prisma/fleet-forgetter.d.ts +1 -1
- package/dist/adapters/prisma/fleet-forgetter.js +2 -2
- package/dist/adapters/prisma/fleet-forgetter.js.map +1 -1
- package/dist/adapters/prisma/generated/browser.d.ts +7 -0
- package/dist/adapters/prisma/generated/client.d.ts +7 -0
- package/dist/adapters/prisma/generated/internal/class.d.ts +11 -0
- package/dist/adapters/prisma/generated/internal/class.js +4 -4
- package/dist/adapters/prisma/generated/internal/class.js.map +1 -1
- package/dist/adapters/prisma/generated/internal/prismaNamespace.d.ts +82 -1
- package/dist/adapters/prisma/generated/internal/prismaNamespace.js +6 -1
- package/dist/adapters/prisma/generated/internal/prismaNamespace.js.map +1 -1
- package/dist/adapters/prisma/generated/internal/prismaNamespaceBrowser.d.ts +6 -0
- package/dist/adapters/prisma/generated/internal/prismaNamespaceBrowser.js +6 -1
- package/dist/adapters/prisma/generated/internal/prismaNamespaceBrowser.js.map +1 -1
- package/dist/adapters/prisma/generated/models/EnabledModel.d.ts +920 -0
- package/dist/adapters/prisma/generated/models/EnabledModel.js +2 -0
- package/dist/adapters/prisma/generated/models/EnabledModel.js.map +1 -0
- package/dist/adapters/prisma/generated/models.d.ts +1 -0
- package/dist/adapters/trpc/router.d.ts +125 -0
- package/dist/adapters/trpc/router.js +15 -1
- package/dist/adapters/trpc/router.js.map +1 -1
- package/dist/app.d.ts +3 -0
- package/dist/app.js +41 -4
- package/dist/app.js.map +1 -1
- package/dist/bin/aeolus-trierarch-plugin.js +1 -0
- package/dist/bin/aeolus-trierarch-plugin.js.map +1 -1
- package/dist/config.d.ts +3 -0
- package/dist/config.js +18 -0
- package/dist/config.js.map +1 -1
- package/dist/core/assignment/assign-crews.d.ts +4 -1
- package/dist/core/assignment/assign-crews.js +4 -2
- package/dist/core/assignment/assign-crews.js.map +1 -1
- package/dist/core/assignment/check-crew-settings.d.ts +4 -2
- package/dist/core/assignment/check-crew-settings.js +3 -3
- package/dist/core/assignment/check-crew-settings.js.map +1 -1
- package/dist/core/assignment/placement.d.ts +14 -3
- package/dist/core/assignment/placement.js +48 -11
- package/dist/core/assignment/placement.js.map +1 -1
- package/dist/core/connection/ports.d.ts +7 -0
- package/dist/core/installation/ports.d.ts +2 -1
- package/dist/core/machines/join-machine.d.ts +2 -1
- package/dist/core/machines/join-machine.js +4 -2
- package/dist/core/machines/join-machine.js.map +1 -1
- package/dist/core/models/list-enabled-models.d.ts +7 -0
- package/dist/core/models/list-enabled-models.js +5 -0
- package/dist/core/models/list-enabled-models.js.map +1 -0
- package/dist/core/models/ports.d.ts +11 -0
- package/dist/core/models/ports.js +2 -0
- package/dist/core/models/ports.js.map +1 -0
- package/dist/core/models/set-model-enabled.d.ts +15 -0
- package/dist/core/models/set-model-enabled.js +12 -0
- package/dist/core/models/set-model-enabled.js.map +1 -0
- package/dist/core/operator/authenticate-operator.d.ts +2 -2
- package/dist/core/operator/ports.d.ts +2 -2
- package/dist/core/repositories/resend-trusted-repositories.d.ts +15 -0
- package/dist/core/repositories/resend-trusted-repositories.js +19 -0
- package/dist/core/repositories/resend-trusted-repositories.js.map +1 -0
- package/dist/core/repositories/share-trusted-repositories.d.ts +25 -0
- package/dist/core/repositories/share-trusted-repositories.js +45 -0
- package/dist/core/repositories/share-trusted-repositories.js.map +1 -0
- package/dist/core/repositories/trusted-repositories.d.ts +22 -0
- package/dist/core/repositories/trusted-repositories.js +91 -0
- package/dist/core/repositories/trusted-repositories.js.map +1 -0
- package/package.json +3 -3
- package/src/adapters/prisma/migrations/20261025100000_enabled_models/migration.sql +7 -0
- package/src/adapters/prisma/schema.prisma +13 -1
|
@@ -0,0 +1,920 @@
|
|
|
1
|
+
import type * as runtime from "@prisma/client/runtime/client";
|
|
2
|
+
import type * as Prisma from "../internal/prismaNamespace.js";
|
|
3
|
+
/**
|
|
4
|
+
* Model EnabledModel
|
|
5
|
+
* The models each fleet's agent ships may be crewed with (decision 0063): exact
|
|
6
|
+
* model ids, one row each. None is no rule. Forgotten with the fleet; switching
|
|
7
|
+
* the trierarch plugin off keeps them.
|
|
8
|
+
*/
|
|
9
|
+
export type EnabledModelModel = runtime.Types.Result.DefaultSelection<Prisma.$EnabledModelPayload>;
|
|
10
|
+
export type AggregateEnabledModel = {
|
|
11
|
+
_count: EnabledModelCountAggregateOutputType | null;
|
|
12
|
+
_min: EnabledModelMinAggregateOutputType | null;
|
|
13
|
+
_max: EnabledModelMaxAggregateOutputType | null;
|
|
14
|
+
};
|
|
15
|
+
export type EnabledModelMinAggregateOutputType = {
|
|
16
|
+
fleetId: string | null;
|
|
17
|
+
model: string | null;
|
|
18
|
+
};
|
|
19
|
+
export type EnabledModelMaxAggregateOutputType = {
|
|
20
|
+
fleetId: string | null;
|
|
21
|
+
model: string | null;
|
|
22
|
+
};
|
|
23
|
+
export type EnabledModelCountAggregateOutputType = {
|
|
24
|
+
fleetId: number;
|
|
25
|
+
model: number;
|
|
26
|
+
_all: number;
|
|
27
|
+
};
|
|
28
|
+
export type EnabledModelMinAggregateInputType = {
|
|
29
|
+
fleetId?: true;
|
|
30
|
+
model?: true;
|
|
31
|
+
};
|
|
32
|
+
export type EnabledModelMaxAggregateInputType = {
|
|
33
|
+
fleetId?: true;
|
|
34
|
+
model?: true;
|
|
35
|
+
};
|
|
36
|
+
export type EnabledModelCountAggregateInputType = {
|
|
37
|
+
fleetId?: true;
|
|
38
|
+
model?: true;
|
|
39
|
+
_all?: true;
|
|
40
|
+
};
|
|
41
|
+
export type EnabledModelAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
42
|
+
/**
|
|
43
|
+
* Filter which EnabledModel to aggregate.
|
|
44
|
+
*/
|
|
45
|
+
where?: Prisma.EnabledModelWhereInput;
|
|
46
|
+
/**
|
|
47
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
48
|
+
*
|
|
49
|
+
* Determine the order of EnabledModels to fetch.
|
|
50
|
+
*/
|
|
51
|
+
orderBy?: Prisma.EnabledModelOrderByWithRelationInput | Prisma.EnabledModelOrderByWithRelationInput[];
|
|
52
|
+
/**
|
|
53
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
54
|
+
*
|
|
55
|
+
* Sets the start position
|
|
56
|
+
*/
|
|
57
|
+
cursor?: Prisma.EnabledModelWhereUniqueInput;
|
|
58
|
+
/**
|
|
59
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
60
|
+
*
|
|
61
|
+
* Take `±n` EnabledModels from the position of the cursor.
|
|
62
|
+
*/
|
|
63
|
+
take?: number;
|
|
64
|
+
/**
|
|
65
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
66
|
+
*
|
|
67
|
+
* Skip the first `n` EnabledModels.
|
|
68
|
+
*/
|
|
69
|
+
skip?: number;
|
|
70
|
+
/**
|
|
71
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
72
|
+
*
|
|
73
|
+
* Count returned EnabledModels
|
|
74
|
+
**/
|
|
75
|
+
_count?: true | EnabledModelCountAggregateInputType;
|
|
76
|
+
/**
|
|
77
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
78
|
+
*
|
|
79
|
+
* Select which fields to find the minimum value
|
|
80
|
+
**/
|
|
81
|
+
_min?: EnabledModelMinAggregateInputType;
|
|
82
|
+
/**
|
|
83
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
84
|
+
*
|
|
85
|
+
* Select which fields to find the maximum value
|
|
86
|
+
**/
|
|
87
|
+
_max?: EnabledModelMaxAggregateInputType;
|
|
88
|
+
};
|
|
89
|
+
export type GetEnabledModelAggregateType<T extends EnabledModelAggregateArgs> = {
|
|
90
|
+
[P in keyof T & keyof AggregateEnabledModel]: P extends '_count' | 'count' ? T[P] extends true ? number : Prisma.GetScalarType<T[P], AggregateEnabledModel[P]> : Prisma.GetScalarType<T[P], AggregateEnabledModel[P]>;
|
|
91
|
+
};
|
|
92
|
+
export type EnabledModelGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
93
|
+
where?: Prisma.EnabledModelWhereInput;
|
|
94
|
+
orderBy?: Prisma.EnabledModelOrderByWithAggregationInput | Prisma.EnabledModelOrderByWithAggregationInput[];
|
|
95
|
+
by: Prisma.EnabledModelScalarFieldEnum[] | Prisma.EnabledModelScalarFieldEnum;
|
|
96
|
+
having?: Prisma.EnabledModelScalarWhereWithAggregatesInput;
|
|
97
|
+
take?: number;
|
|
98
|
+
skip?: number;
|
|
99
|
+
_count?: EnabledModelCountAggregateInputType | true;
|
|
100
|
+
_min?: EnabledModelMinAggregateInputType;
|
|
101
|
+
_max?: EnabledModelMaxAggregateInputType;
|
|
102
|
+
};
|
|
103
|
+
export type EnabledModelGroupByOutputType = {
|
|
104
|
+
fleetId: string;
|
|
105
|
+
model: string;
|
|
106
|
+
_count: EnabledModelCountAggregateOutputType | null;
|
|
107
|
+
_min: EnabledModelMinAggregateOutputType | null;
|
|
108
|
+
_max: EnabledModelMaxAggregateOutputType | null;
|
|
109
|
+
};
|
|
110
|
+
export type GetEnabledModelGroupByPayload<T extends EnabledModelGroupByArgs> = Prisma.PrismaPromise<Array<Prisma.PickEnumerable<EnabledModelGroupByOutputType, T['by']> & {
|
|
111
|
+
[P in ((keyof T) & (keyof EnabledModelGroupByOutputType))]: P extends '_count' ? T[P] extends boolean ? number : Prisma.GetScalarType<T[P], EnabledModelGroupByOutputType[P]> : Prisma.GetScalarType<T[P], EnabledModelGroupByOutputType[P]>;
|
|
112
|
+
}>>;
|
|
113
|
+
export type EnabledModelWhereInput = {
|
|
114
|
+
AND?: Prisma.EnabledModelWhereInput | Prisma.EnabledModelWhereInput[];
|
|
115
|
+
OR?: Prisma.EnabledModelWhereInput[];
|
|
116
|
+
NOT?: Prisma.EnabledModelWhereInput | Prisma.EnabledModelWhereInput[];
|
|
117
|
+
fleetId?: Prisma.StringFilter<"EnabledModel"> | string;
|
|
118
|
+
model?: Prisma.StringFilter<"EnabledModel"> | string;
|
|
119
|
+
};
|
|
120
|
+
export type EnabledModelOrderByWithRelationInput = {
|
|
121
|
+
fleetId?: Prisma.SortOrder;
|
|
122
|
+
model?: Prisma.SortOrder;
|
|
123
|
+
};
|
|
124
|
+
export type EnabledModelWhereUniqueInput = Prisma.AtLeast<{
|
|
125
|
+
fleetId_model?: Prisma.EnabledModelFleetIdModelCompoundUniqueInput;
|
|
126
|
+
AND?: Prisma.EnabledModelWhereInput | Prisma.EnabledModelWhereInput[];
|
|
127
|
+
OR?: Prisma.EnabledModelWhereInput[];
|
|
128
|
+
NOT?: Prisma.EnabledModelWhereInput | Prisma.EnabledModelWhereInput[];
|
|
129
|
+
fleetId?: Prisma.StringFilter<"EnabledModel"> | string;
|
|
130
|
+
model?: Prisma.StringFilter<"EnabledModel"> | string;
|
|
131
|
+
}, "fleetId_model">;
|
|
132
|
+
export type EnabledModelOrderByWithAggregationInput = {
|
|
133
|
+
fleetId?: Prisma.SortOrder;
|
|
134
|
+
model?: Prisma.SortOrder;
|
|
135
|
+
_count?: Prisma.EnabledModelCountOrderByAggregateInput;
|
|
136
|
+
_max?: Prisma.EnabledModelMaxOrderByAggregateInput;
|
|
137
|
+
_min?: Prisma.EnabledModelMinOrderByAggregateInput;
|
|
138
|
+
};
|
|
139
|
+
export type EnabledModelScalarWhereWithAggregatesInput = {
|
|
140
|
+
AND?: Prisma.EnabledModelScalarWhereWithAggregatesInput | Prisma.EnabledModelScalarWhereWithAggregatesInput[];
|
|
141
|
+
OR?: Prisma.EnabledModelScalarWhereWithAggregatesInput[];
|
|
142
|
+
NOT?: Prisma.EnabledModelScalarWhereWithAggregatesInput | Prisma.EnabledModelScalarWhereWithAggregatesInput[];
|
|
143
|
+
fleetId?: Prisma.StringWithAggregatesFilter<"EnabledModel"> | string;
|
|
144
|
+
model?: Prisma.StringWithAggregatesFilter<"EnabledModel"> | string;
|
|
145
|
+
};
|
|
146
|
+
export type EnabledModelCreateInput = {
|
|
147
|
+
fleetId: string;
|
|
148
|
+
model: string;
|
|
149
|
+
};
|
|
150
|
+
export type EnabledModelUncheckedCreateInput = {
|
|
151
|
+
fleetId: string;
|
|
152
|
+
model: string;
|
|
153
|
+
};
|
|
154
|
+
export type EnabledModelUpdateInput = {
|
|
155
|
+
fleetId?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
156
|
+
model?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
157
|
+
};
|
|
158
|
+
export type EnabledModelUncheckedUpdateInput = {
|
|
159
|
+
fleetId?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
160
|
+
model?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
161
|
+
};
|
|
162
|
+
export type EnabledModelCreateManyInput = {
|
|
163
|
+
fleetId: string;
|
|
164
|
+
model: string;
|
|
165
|
+
};
|
|
166
|
+
export type EnabledModelUpdateManyMutationInput = {
|
|
167
|
+
fleetId?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
168
|
+
model?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
169
|
+
};
|
|
170
|
+
export type EnabledModelUncheckedUpdateManyInput = {
|
|
171
|
+
fleetId?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
172
|
+
model?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
173
|
+
};
|
|
174
|
+
export type EnabledModelFleetIdModelCompoundUniqueInput = {
|
|
175
|
+
fleetId: string;
|
|
176
|
+
model: string;
|
|
177
|
+
};
|
|
178
|
+
export type EnabledModelCountOrderByAggregateInput = {
|
|
179
|
+
fleetId?: Prisma.SortOrder;
|
|
180
|
+
model?: Prisma.SortOrder;
|
|
181
|
+
};
|
|
182
|
+
export type EnabledModelMaxOrderByAggregateInput = {
|
|
183
|
+
fleetId?: Prisma.SortOrder;
|
|
184
|
+
model?: Prisma.SortOrder;
|
|
185
|
+
};
|
|
186
|
+
export type EnabledModelMinOrderByAggregateInput = {
|
|
187
|
+
fleetId?: Prisma.SortOrder;
|
|
188
|
+
model?: Prisma.SortOrder;
|
|
189
|
+
};
|
|
190
|
+
export type EnabledModelSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
|
|
191
|
+
fleetId?: boolean;
|
|
192
|
+
model?: boolean;
|
|
193
|
+
}, ExtArgs["result"]["enabledModel"]>;
|
|
194
|
+
export type EnabledModelSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
|
|
195
|
+
fleetId?: boolean;
|
|
196
|
+
model?: boolean;
|
|
197
|
+
}, ExtArgs["result"]["enabledModel"]>;
|
|
198
|
+
export type EnabledModelSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
|
|
199
|
+
fleetId?: boolean;
|
|
200
|
+
model?: boolean;
|
|
201
|
+
}, ExtArgs["result"]["enabledModel"]>;
|
|
202
|
+
export type EnabledModelSelectScalar = {
|
|
203
|
+
fleetId?: boolean;
|
|
204
|
+
model?: boolean;
|
|
205
|
+
};
|
|
206
|
+
export type EnabledModelOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"fleetId" | "model", ExtArgs["result"]["enabledModel"]>;
|
|
207
|
+
export type $EnabledModelPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
208
|
+
name: "EnabledModel";
|
|
209
|
+
objects: {};
|
|
210
|
+
scalars: runtime.Types.Extensions.GetPayloadResult<{
|
|
211
|
+
fleetId: string;
|
|
212
|
+
model: string;
|
|
213
|
+
}, ExtArgs["result"]["enabledModel"]>;
|
|
214
|
+
composites: {};
|
|
215
|
+
};
|
|
216
|
+
export type EnabledModelGetPayload<S extends boolean | null | undefined | EnabledModelDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$EnabledModelPayload, S>;
|
|
217
|
+
export type EnabledModelCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = Omit<EnabledModelFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
218
|
+
select?: EnabledModelCountAggregateInputType | true;
|
|
219
|
+
};
|
|
220
|
+
export interface EnabledModelDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
221
|
+
[K: symbol]: {
|
|
222
|
+
types: Prisma.TypeMap<ExtArgs>['model']['EnabledModel'];
|
|
223
|
+
meta: {
|
|
224
|
+
name: 'EnabledModel';
|
|
225
|
+
};
|
|
226
|
+
};
|
|
227
|
+
/**
|
|
228
|
+
* Find zero or one EnabledModel that matches the filter.
|
|
229
|
+
* @param {EnabledModelFindUniqueArgs} args - Arguments to find a EnabledModel
|
|
230
|
+
* @example
|
|
231
|
+
* // Get one EnabledModel
|
|
232
|
+
* const enabledModel = await prisma.enabledModel.findUnique({
|
|
233
|
+
* where: {
|
|
234
|
+
* // ... provide filter here
|
|
235
|
+
* }
|
|
236
|
+
* })
|
|
237
|
+
*/
|
|
238
|
+
findUnique<T extends EnabledModelFindUniqueArgs>(args: Prisma.SelectSubset<T, EnabledModelFindUniqueArgs<ExtArgs>>): Prisma.Prisma__EnabledModelClient<runtime.Types.Result.GetResult<Prisma.$EnabledModelPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>;
|
|
239
|
+
/**
|
|
240
|
+
* Find one EnabledModel that matches the filter or throw an error with `error.code='P2025'`
|
|
241
|
+
* if no matches were found.
|
|
242
|
+
* @param {EnabledModelFindUniqueOrThrowArgs} args - Arguments to find a EnabledModel
|
|
243
|
+
* @example
|
|
244
|
+
* // Get one EnabledModel
|
|
245
|
+
* const enabledModel = await prisma.enabledModel.findUniqueOrThrow({
|
|
246
|
+
* where: {
|
|
247
|
+
* // ... provide filter here
|
|
248
|
+
* }
|
|
249
|
+
* })
|
|
250
|
+
*/
|
|
251
|
+
findUniqueOrThrow<T extends EnabledModelFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, EnabledModelFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__EnabledModelClient<runtime.Types.Result.GetResult<Prisma.$EnabledModelPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
|
|
252
|
+
/**
|
|
253
|
+
* Find the first EnabledModel that matches the filter.
|
|
254
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
255
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
256
|
+
* @param {EnabledModelFindFirstArgs} args - Arguments to find a EnabledModel
|
|
257
|
+
* @example
|
|
258
|
+
* // Get one EnabledModel
|
|
259
|
+
* const enabledModel = await prisma.enabledModel.findFirst({
|
|
260
|
+
* where: {
|
|
261
|
+
* // ... provide filter here
|
|
262
|
+
* }
|
|
263
|
+
* })
|
|
264
|
+
*/
|
|
265
|
+
findFirst<T extends EnabledModelFindFirstArgs>(args?: Prisma.SelectSubset<T, EnabledModelFindFirstArgs<ExtArgs>>): Prisma.Prisma__EnabledModelClient<runtime.Types.Result.GetResult<Prisma.$EnabledModelPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>;
|
|
266
|
+
/**
|
|
267
|
+
* Find the first EnabledModel that matches the filter or
|
|
268
|
+
* throw `PrismaKnownClientError` with `P2025` code if no matches were found.
|
|
269
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
270
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
271
|
+
* @param {EnabledModelFindFirstOrThrowArgs} args - Arguments to find a EnabledModel
|
|
272
|
+
* @example
|
|
273
|
+
* // Get one EnabledModel
|
|
274
|
+
* const enabledModel = await prisma.enabledModel.findFirstOrThrow({
|
|
275
|
+
* where: {
|
|
276
|
+
* // ... provide filter here
|
|
277
|
+
* }
|
|
278
|
+
* })
|
|
279
|
+
*/
|
|
280
|
+
findFirstOrThrow<T extends EnabledModelFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, EnabledModelFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__EnabledModelClient<runtime.Types.Result.GetResult<Prisma.$EnabledModelPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
|
|
281
|
+
/**
|
|
282
|
+
* Find zero or more EnabledModels that matches the filter.
|
|
283
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
284
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
285
|
+
* @param {EnabledModelFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
286
|
+
* @example
|
|
287
|
+
* // Get all EnabledModels
|
|
288
|
+
* const enabledModels = await prisma.enabledModel.findMany()
|
|
289
|
+
*
|
|
290
|
+
* // Get first 10 EnabledModels
|
|
291
|
+
* const enabledModels = await prisma.enabledModel.findMany({ take: 10 })
|
|
292
|
+
*
|
|
293
|
+
* // Only select the `fleetId`
|
|
294
|
+
* const enabledModelWithFleetIdOnly = await prisma.enabledModel.findMany({ select: { fleetId: true } })
|
|
295
|
+
*
|
|
296
|
+
*/
|
|
297
|
+
findMany<T extends EnabledModelFindManyArgs>(args?: Prisma.SelectSubset<T, EnabledModelFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$EnabledModelPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>;
|
|
298
|
+
/**
|
|
299
|
+
* Create a EnabledModel.
|
|
300
|
+
* @param {EnabledModelCreateArgs} args - Arguments to create a EnabledModel.
|
|
301
|
+
* @example
|
|
302
|
+
* // Create one EnabledModel
|
|
303
|
+
* const EnabledModel = await prisma.enabledModel.create({
|
|
304
|
+
* data: {
|
|
305
|
+
* // ... data to create a EnabledModel
|
|
306
|
+
* }
|
|
307
|
+
* })
|
|
308
|
+
*
|
|
309
|
+
*/
|
|
310
|
+
create<T extends EnabledModelCreateArgs>(args: Prisma.SelectSubset<T, EnabledModelCreateArgs<ExtArgs>>): Prisma.Prisma__EnabledModelClient<runtime.Types.Result.GetResult<Prisma.$EnabledModelPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
|
|
311
|
+
/**
|
|
312
|
+
* Create many EnabledModels.
|
|
313
|
+
* @param {EnabledModelCreateManyArgs} args - Arguments to create many EnabledModels.
|
|
314
|
+
* @example
|
|
315
|
+
* // Create many EnabledModels
|
|
316
|
+
* const enabledModel = await prisma.enabledModel.createMany({
|
|
317
|
+
* data: [
|
|
318
|
+
* // ... provide data here
|
|
319
|
+
* ]
|
|
320
|
+
* })
|
|
321
|
+
*
|
|
322
|
+
*/
|
|
323
|
+
createMany<T extends EnabledModelCreateManyArgs>(args?: Prisma.SelectSubset<T, EnabledModelCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>;
|
|
324
|
+
/**
|
|
325
|
+
* Create many EnabledModels and returns the data saved in the database.
|
|
326
|
+
* @param {EnabledModelCreateManyAndReturnArgs} args - Arguments to create many EnabledModels.
|
|
327
|
+
* @example
|
|
328
|
+
* // Create many EnabledModels
|
|
329
|
+
* const enabledModel = await prisma.enabledModel.createManyAndReturn({
|
|
330
|
+
* data: [
|
|
331
|
+
* // ... provide data here
|
|
332
|
+
* ]
|
|
333
|
+
* })
|
|
334
|
+
*
|
|
335
|
+
* // Create many EnabledModels and only return the `fleetId`
|
|
336
|
+
* const enabledModelWithFleetIdOnly = await prisma.enabledModel.createManyAndReturn({
|
|
337
|
+
* select: { fleetId: true },
|
|
338
|
+
* data: [
|
|
339
|
+
* // ... provide data here
|
|
340
|
+
* ]
|
|
341
|
+
* })
|
|
342
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
343
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
344
|
+
*
|
|
345
|
+
*/
|
|
346
|
+
createManyAndReturn<T extends EnabledModelCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, EnabledModelCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$EnabledModelPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>;
|
|
347
|
+
/**
|
|
348
|
+
* Delete a EnabledModel.
|
|
349
|
+
* @param {EnabledModelDeleteArgs} args - Arguments to delete one EnabledModel.
|
|
350
|
+
* @example
|
|
351
|
+
* // Delete one EnabledModel
|
|
352
|
+
* const EnabledModel = await prisma.enabledModel.delete({
|
|
353
|
+
* where: {
|
|
354
|
+
* // ... filter to delete one EnabledModel
|
|
355
|
+
* }
|
|
356
|
+
* })
|
|
357
|
+
*
|
|
358
|
+
*/
|
|
359
|
+
delete<T extends EnabledModelDeleteArgs>(args: Prisma.SelectSubset<T, EnabledModelDeleteArgs<ExtArgs>>): Prisma.Prisma__EnabledModelClient<runtime.Types.Result.GetResult<Prisma.$EnabledModelPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
|
|
360
|
+
/**
|
|
361
|
+
* Update one EnabledModel.
|
|
362
|
+
* @param {EnabledModelUpdateArgs} args - Arguments to update one EnabledModel.
|
|
363
|
+
* @example
|
|
364
|
+
* // Update one EnabledModel
|
|
365
|
+
* const enabledModel = await prisma.enabledModel.update({
|
|
366
|
+
* where: {
|
|
367
|
+
* // ... provide filter here
|
|
368
|
+
* },
|
|
369
|
+
* data: {
|
|
370
|
+
* // ... provide data here
|
|
371
|
+
* }
|
|
372
|
+
* })
|
|
373
|
+
*
|
|
374
|
+
*/
|
|
375
|
+
update<T extends EnabledModelUpdateArgs>(args: Prisma.SelectSubset<T, EnabledModelUpdateArgs<ExtArgs>>): Prisma.Prisma__EnabledModelClient<runtime.Types.Result.GetResult<Prisma.$EnabledModelPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
|
|
376
|
+
/**
|
|
377
|
+
* Delete zero or more EnabledModels.
|
|
378
|
+
* @param {EnabledModelDeleteManyArgs} args - Arguments to filter EnabledModels to delete.
|
|
379
|
+
* @example
|
|
380
|
+
* // Delete a few EnabledModels
|
|
381
|
+
* const { count } = await prisma.enabledModel.deleteMany({
|
|
382
|
+
* where: {
|
|
383
|
+
* // ... provide filter here
|
|
384
|
+
* }
|
|
385
|
+
* })
|
|
386
|
+
*
|
|
387
|
+
*/
|
|
388
|
+
deleteMany<T extends EnabledModelDeleteManyArgs>(args?: Prisma.SelectSubset<T, EnabledModelDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>;
|
|
389
|
+
/**
|
|
390
|
+
* Update zero or more EnabledModels.
|
|
391
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
392
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
393
|
+
* @param {EnabledModelUpdateManyArgs} args - Arguments to update one or more rows.
|
|
394
|
+
* @example
|
|
395
|
+
* // Update many EnabledModels
|
|
396
|
+
* const enabledModel = await prisma.enabledModel.updateMany({
|
|
397
|
+
* where: {
|
|
398
|
+
* // ... provide filter here
|
|
399
|
+
* },
|
|
400
|
+
* data: {
|
|
401
|
+
* // ... provide data here
|
|
402
|
+
* }
|
|
403
|
+
* })
|
|
404
|
+
*
|
|
405
|
+
*/
|
|
406
|
+
updateMany<T extends EnabledModelUpdateManyArgs>(args: Prisma.SelectSubset<T, EnabledModelUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>;
|
|
407
|
+
/**
|
|
408
|
+
* Update zero or more EnabledModels and returns the data updated in the database.
|
|
409
|
+
* @param {EnabledModelUpdateManyAndReturnArgs} args - Arguments to update many EnabledModels.
|
|
410
|
+
* @example
|
|
411
|
+
* // Update many EnabledModels
|
|
412
|
+
* const enabledModel = await prisma.enabledModel.updateManyAndReturn({
|
|
413
|
+
* where: {
|
|
414
|
+
* // ... provide filter here
|
|
415
|
+
* },
|
|
416
|
+
* data: [
|
|
417
|
+
* // ... provide data here
|
|
418
|
+
* ]
|
|
419
|
+
* })
|
|
420
|
+
*
|
|
421
|
+
* // Update zero or more EnabledModels and only return the `fleetId`
|
|
422
|
+
* const enabledModelWithFleetIdOnly = await prisma.enabledModel.updateManyAndReturn({
|
|
423
|
+
* select: { fleetId: true },
|
|
424
|
+
* where: {
|
|
425
|
+
* // ... provide filter here
|
|
426
|
+
* },
|
|
427
|
+
* data: [
|
|
428
|
+
* // ... provide data here
|
|
429
|
+
* ]
|
|
430
|
+
* })
|
|
431
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
432
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
433
|
+
*
|
|
434
|
+
*/
|
|
435
|
+
updateManyAndReturn<T extends EnabledModelUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, EnabledModelUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$EnabledModelPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>;
|
|
436
|
+
/**
|
|
437
|
+
* Create or update one EnabledModel.
|
|
438
|
+
* @param {EnabledModelUpsertArgs} args - Arguments to update or create a EnabledModel.
|
|
439
|
+
* @example
|
|
440
|
+
* // Update or create a EnabledModel
|
|
441
|
+
* const enabledModel = await prisma.enabledModel.upsert({
|
|
442
|
+
* create: {
|
|
443
|
+
* // ... data to create a EnabledModel
|
|
444
|
+
* },
|
|
445
|
+
* update: {
|
|
446
|
+
* // ... in case it already exists, update
|
|
447
|
+
* },
|
|
448
|
+
* where: {
|
|
449
|
+
* // ... the filter for the EnabledModel we want to update
|
|
450
|
+
* }
|
|
451
|
+
* })
|
|
452
|
+
*/
|
|
453
|
+
upsert<T extends EnabledModelUpsertArgs>(args: Prisma.SelectSubset<T, EnabledModelUpsertArgs<ExtArgs>>): Prisma.Prisma__EnabledModelClient<runtime.Types.Result.GetResult<Prisma.$EnabledModelPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
|
|
454
|
+
/**
|
|
455
|
+
* Count the number of EnabledModels.
|
|
456
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
457
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
458
|
+
* @param {EnabledModelCountArgs} args - Arguments to filter EnabledModels to count.
|
|
459
|
+
* @example
|
|
460
|
+
* // Count the number of EnabledModels
|
|
461
|
+
* const count = await prisma.enabledModel.count({
|
|
462
|
+
* where: {
|
|
463
|
+
* // ... the filter for the EnabledModels we want to count
|
|
464
|
+
* }
|
|
465
|
+
* })
|
|
466
|
+
**/
|
|
467
|
+
count<T extends EnabledModelCountArgs>(args?: Prisma.Subset<T, EnabledModelCountArgs>): Prisma.PrismaPromise<T extends runtime.Types.Utils.Record<'select', any> ? T['select'] extends true ? number : Prisma.GetScalarType<T['select'], EnabledModelCountAggregateOutputType> : number>;
|
|
468
|
+
/**
|
|
469
|
+
* Allows you to perform aggregations operations on a EnabledModel.
|
|
470
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
471
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
472
|
+
* @param {EnabledModelAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
|
|
473
|
+
* @example
|
|
474
|
+
* // Ordered by age ascending
|
|
475
|
+
* // Where email contains prisma.io
|
|
476
|
+
* // Limited to the 10 users
|
|
477
|
+
* const aggregations = await prisma.user.aggregate({
|
|
478
|
+
* _avg: {
|
|
479
|
+
* age: true,
|
|
480
|
+
* },
|
|
481
|
+
* where: {
|
|
482
|
+
* email: {
|
|
483
|
+
* contains: "prisma.io",
|
|
484
|
+
* },
|
|
485
|
+
* },
|
|
486
|
+
* orderBy: {
|
|
487
|
+
* age: "asc",
|
|
488
|
+
* },
|
|
489
|
+
* take: 10,
|
|
490
|
+
* })
|
|
491
|
+
**/
|
|
492
|
+
aggregate<T extends EnabledModelAggregateArgs>(args: Prisma.Subset<T, EnabledModelAggregateArgs>): Prisma.PrismaPromise<GetEnabledModelAggregateType<T>>;
|
|
493
|
+
/**
|
|
494
|
+
* Group by EnabledModel.
|
|
495
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
496
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
497
|
+
* @param {EnabledModelGroupByArgs} args - Group by arguments.
|
|
498
|
+
* @example
|
|
499
|
+
* // Group by city, order by createdAt, get count
|
|
500
|
+
* const result = await prisma.user.groupBy({
|
|
501
|
+
* by: ['city', 'createdAt'],
|
|
502
|
+
* orderBy: {
|
|
503
|
+
* createdAt: true
|
|
504
|
+
* },
|
|
505
|
+
* _count: {
|
|
506
|
+
* _all: true
|
|
507
|
+
* },
|
|
508
|
+
* })
|
|
509
|
+
*
|
|
510
|
+
**/
|
|
511
|
+
groupBy<T extends EnabledModelGroupByArgs, HasSelectOrTake extends Prisma.Or<Prisma.Extends<'skip', Prisma.Keys<T>>, Prisma.Extends<'take', Prisma.Keys<T>>>, OrderByArg extends Prisma.True extends HasSelectOrTake ? {
|
|
512
|
+
orderBy: EnabledModelGroupByArgs['orderBy'];
|
|
513
|
+
} : {
|
|
514
|
+
orderBy?: EnabledModelGroupByArgs['orderBy'];
|
|
515
|
+
}, 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 ? {
|
|
516
|
+
[P in HavingFields]: P extends ByFields ? never : P extends string ? `Error: Field "${P}" used in "having" needs to be provided in "by".` : [
|
|
517
|
+
Error,
|
|
518
|
+
'Field ',
|
|
519
|
+
P,
|
|
520
|
+
` in "having" needs to be provided in "by"`
|
|
521
|
+
];
|
|
522
|
+
}[HavingFields] : 'take' extends Prisma.Keys<T> ? 'orderBy' extends Prisma.Keys<T> ? ByValid extends Prisma.True ? {} : {
|
|
523
|
+
[P in OrderFields]: P extends ByFields ? never : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`;
|
|
524
|
+
}[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 ? {} : {
|
|
525
|
+
[P in OrderFields]: P extends ByFields ? never : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`;
|
|
526
|
+
}[OrderFields] : 'Error: If you provide "skip", you also need to provide "orderBy"' : ByValid extends Prisma.True ? {} : {
|
|
527
|
+
[P in OrderFields]: P extends ByFields ? never : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`;
|
|
528
|
+
}[OrderFields]>(args: Prisma.SubsetIntersection<T, EnabledModelGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetEnabledModelGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>;
|
|
529
|
+
/**
|
|
530
|
+
* Fields of the EnabledModel model
|
|
531
|
+
*/
|
|
532
|
+
readonly fields: EnabledModelFieldRefs;
|
|
533
|
+
}
|
|
534
|
+
/**
|
|
535
|
+
* The delegate class that acts as a "Promise-like" for EnabledModel.
|
|
536
|
+
* Why is this prefixed with `Prisma__`?
|
|
537
|
+
* Because we want to prevent naming conflicts as mentioned in
|
|
538
|
+
* https://github.com/prisma/prisma-client-js/issues/707
|
|
539
|
+
*/
|
|
540
|
+
export interface Prisma__EnabledModelClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
541
|
+
readonly [Symbol.toStringTag]: "PrismaPromise";
|
|
542
|
+
/**
|
|
543
|
+
* Attaches callbacks for the resolution and/or rejection of the Promise.
|
|
544
|
+
* @param onfulfilled The callback to execute when the Promise is resolved.
|
|
545
|
+
* @param onrejected The callback to execute when the Promise is rejected.
|
|
546
|
+
* @returns A Promise for the completion of which ever callback is executed.
|
|
547
|
+
*/
|
|
548
|
+
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>;
|
|
549
|
+
/**
|
|
550
|
+
* Attaches a callback for only the rejection of the Promise.
|
|
551
|
+
* @param onrejected The callback to execute when the Promise is rejected.
|
|
552
|
+
* @returns A Promise for the completion of the callback.
|
|
553
|
+
*/
|
|
554
|
+
catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>;
|
|
555
|
+
/**
|
|
556
|
+
* Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
|
|
557
|
+
* resolved value cannot be modified from the callback.
|
|
558
|
+
* @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
|
|
559
|
+
* @returns A Promise for the completion of the callback.
|
|
560
|
+
*/
|
|
561
|
+
finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>;
|
|
562
|
+
}
|
|
563
|
+
/**
|
|
564
|
+
* Fields of the EnabledModel model
|
|
565
|
+
*/
|
|
566
|
+
export interface EnabledModelFieldRefs {
|
|
567
|
+
readonly fleetId: Prisma.FieldRef<"EnabledModel", 'String'>;
|
|
568
|
+
readonly model: Prisma.FieldRef<"EnabledModel", 'String'>;
|
|
569
|
+
}
|
|
570
|
+
/**
|
|
571
|
+
* EnabledModel findUnique
|
|
572
|
+
*/
|
|
573
|
+
export type EnabledModelFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
574
|
+
/**
|
|
575
|
+
* Select specific fields to fetch from the EnabledModel
|
|
576
|
+
*/
|
|
577
|
+
select?: Prisma.EnabledModelSelect<ExtArgs> | null;
|
|
578
|
+
/**
|
|
579
|
+
* Omit specific fields from the EnabledModel
|
|
580
|
+
*/
|
|
581
|
+
omit?: Prisma.EnabledModelOmit<ExtArgs> | null;
|
|
582
|
+
/**
|
|
583
|
+
* Filter, which EnabledModel to fetch.
|
|
584
|
+
*/
|
|
585
|
+
where: Prisma.EnabledModelWhereUniqueInput;
|
|
586
|
+
};
|
|
587
|
+
/**
|
|
588
|
+
* EnabledModel findUniqueOrThrow
|
|
589
|
+
*/
|
|
590
|
+
export type EnabledModelFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
591
|
+
/**
|
|
592
|
+
* Select specific fields to fetch from the EnabledModel
|
|
593
|
+
*/
|
|
594
|
+
select?: Prisma.EnabledModelSelect<ExtArgs> | null;
|
|
595
|
+
/**
|
|
596
|
+
* Omit specific fields from the EnabledModel
|
|
597
|
+
*/
|
|
598
|
+
omit?: Prisma.EnabledModelOmit<ExtArgs> | null;
|
|
599
|
+
/**
|
|
600
|
+
* Filter, which EnabledModel to fetch.
|
|
601
|
+
*/
|
|
602
|
+
where: Prisma.EnabledModelWhereUniqueInput;
|
|
603
|
+
};
|
|
604
|
+
/**
|
|
605
|
+
* EnabledModel findFirst
|
|
606
|
+
*/
|
|
607
|
+
export type EnabledModelFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
608
|
+
/**
|
|
609
|
+
* Select specific fields to fetch from the EnabledModel
|
|
610
|
+
*/
|
|
611
|
+
select?: Prisma.EnabledModelSelect<ExtArgs> | null;
|
|
612
|
+
/**
|
|
613
|
+
* Omit specific fields from the EnabledModel
|
|
614
|
+
*/
|
|
615
|
+
omit?: Prisma.EnabledModelOmit<ExtArgs> | null;
|
|
616
|
+
/**
|
|
617
|
+
* Filter, which EnabledModel to fetch.
|
|
618
|
+
*/
|
|
619
|
+
where?: Prisma.EnabledModelWhereInput;
|
|
620
|
+
/**
|
|
621
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
622
|
+
*
|
|
623
|
+
* Determine the order of EnabledModels to fetch.
|
|
624
|
+
*/
|
|
625
|
+
orderBy?: Prisma.EnabledModelOrderByWithRelationInput | Prisma.EnabledModelOrderByWithRelationInput[];
|
|
626
|
+
/**
|
|
627
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
628
|
+
*
|
|
629
|
+
* Sets the position for searching for EnabledModels.
|
|
630
|
+
*/
|
|
631
|
+
cursor?: Prisma.EnabledModelWhereUniqueInput;
|
|
632
|
+
/**
|
|
633
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
634
|
+
*
|
|
635
|
+
* Take `±n` EnabledModels from the position of the cursor.
|
|
636
|
+
*/
|
|
637
|
+
take?: number;
|
|
638
|
+
/**
|
|
639
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
640
|
+
*
|
|
641
|
+
* Skip the first `n` EnabledModels.
|
|
642
|
+
*/
|
|
643
|
+
skip?: number;
|
|
644
|
+
/**
|
|
645
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
646
|
+
*
|
|
647
|
+
* Filter by unique combinations of EnabledModels.
|
|
648
|
+
*/
|
|
649
|
+
distinct?: Prisma.EnabledModelScalarFieldEnum | Prisma.EnabledModelScalarFieldEnum[];
|
|
650
|
+
};
|
|
651
|
+
/**
|
|
652
|
+
* EnabledModel findFirstOrThrow
|
|
653
|
+
*/
|
|
654
|
+
export type EnabledModelFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
655
|
+
/**
|
|
656
|
+
* Select specific fields to fetch from the EnabledModel
|
|
657
|
+
*/
|
|
658
|
+
select?: Prisma.EnabledModelSelect<ExtArgs> | null;
|
|
659
|
+
/**
|
|
660
|
+
* Omit specific fields from the EnabledModel
|
|
661
|
+
*/
|
|
662
|
+
omit?: Prisma.EnabledModelOmit<ExtArgs> | null;
|
|
663
|
+
/**
|
|
664
|
+
* Filter, which EnabledModel to fetch.
|
|
665
|
+
*/
|
|
666
|
+
where?: Prisma.EnabledModelWhereInput;
|
|
667
|
+
/**
|
|
668
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
669
|
+
*
|
|
670
|
+
* Determine the order of EnabledModels to fetch.
|
|
671
|
+
*/
|
|
672
|
+
orderBy?: Prisma.EnabledModelOrderByWithRelationInput | Prisma.EnabledModelOrderByWithRelationInput[];
|
|
673
|
+
/**
|
|
674
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
675
|
+
*
|
|
676
|
+
* Sets the position for searching for EnabledModels.
|
|
677
|
+
*/
|
|
678
|
+
cursor?: Prisma.EnabledModelWhereUniqueInput;
|
|
679
|
+
/**
|
|
680
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
681
|
+
*
|
|
682
|
+
* Take `±n` EnabledModels from the position of the cursor.
|
|
683
|
+
*/
|
|
684
|
+
take?: number;
|
|
685
|
+
/**
|
|
686
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
687
|
+
*
|
|
688
|
+
* Skip the first `n` EnabledModels.
|
|
689
|
+
*/
|
|
690
|
+
skip?: number;
|
|
691
|
+
/**
|
|
692
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
693
|
+
*
|
|
694
|
+
* Filter by unique combinations of EnabledModels.
|
|
695
|
+
*/
|
|
696
|
+
distinct?: Prisma.EnabledModelScalarFieldEnum | Prisma.EnabledModelScalarFieldEnum[];
|
|
697
|
+
};
|
|
698
|
+
/**
|
|
699
|
+
* EnabledModel findMany
|
|
700
|
+
*/
|
|
701
|
+
export type EnabledModelFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
702
|
+
/**
|
|
703
|
+
* Select specific fields to fetch from the EnabledModel
|
|
704
|
+
*/
|
|
705
|
+
select?: Prisma.EnabledModelSelect<ExtArgs> | null;
|
|
706
|
+
/**
|
|
707
|
+
* Omit specific fields from the EnabledModel
|
|
708
|
+
*/
|
|
709
|
+
omit?: Prisma.EnabledModelOmit<ExtArgs> | null;
|
|
710
|
+
/**
|
|
711
|
+
* Filter, which EnabledModels to fetch.
|
|
712
|
+
*/
|
|
713
|
+
where?: Prisma.EnabledModelWhereInput;
|
|
714
|
+
/**
|
|
715
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
716
|
+
*
|
|
717
|
+
* Determine the order of EnabledModels to fetch.
|
|
718
|
+
*/
|
|
719
|
+
orderBy?: Prisma.EnabledModelOrderByWithRelationInput | Prisma.EnabledModelOrderByWithRelationInput[];
|
|
720
|
+
/**
|
|
721
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
722
|
+
*
|
|
723
|
+
* Sets the position for listing EnabledModels.
|
|
724
|
+
*/
|
|
725
|
+
cursor?: Prisma.EnabledModelWhereUniqueInput;
|
|
726
|
+
/**
|
|
727
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
728
|
+
*
|
|
729
|
+
* Take `±n` EnabledModels from the position of the cursor.
|
|
730
|
+
*/
|
|
731
|
+
take?: number;
|
|
732
|
+
/**
|
|
733
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
734
|
+
*
|
|
735
|
+
* Skip the first `n` EnabledModels.
|
|
736
|
+
*/
|
|
737
|
+
skip?: number;
|
|
738
|
+
/**
|
|
739
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
740
|
+
*
|
|
741
|
+
* Filter by unique combinations of EnabledModels.
|
|
742
|
+
*/
|
|
743
|
+
distinct?: Prisma.EnabledModelScalarFieldEnum | Prisma.EnabledModelScalarFieldEnum[];
|
|
744
|
+
};
|
|
745
|
+
/**
|
|
746
|
+
* EnabledModel create
|
|
747
|
+
*/
|
|
748
|
+
export type EnabledModelCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
749
|
+
/**
|
|
750
|
+
* Select specific fields to fetch from the EnabledModel
|
|
751
|
+
*/
|
|
752
|
+
select?: Prisma.EnabledModelSelect<ExtArgs> | null;
|
|
753
|
+
/**
|
|
754
|
+
* Omit specific fields from the EnabledModel
|
|
755
|
+
*/
|
|
756
|
+
omit?: Prisma.EnabledModelOmit<ExtArgs> | null;
|
|
757
|
+
/**
|
|
758
|
+
* The data needed to create a EnabledModel.
|
|
759
|
+
*/
|
|
760
|
+
data: Prisma.XOR<Prisma.EnabledModelCreateInput, Prisma.EnabledModelUncheckedCreateInput>;
|
|
761
|
+
};
|
|
762
|
+
/**
|
|
763
|
+
* EnabledModel createMany
|
|
764
|
+
*/
|
|
765
|
+
export type EnabledModelCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
766
|
+
/**
|
|
767
|
+
* The data used to create many EnabledModels.
|
|
768
|
+
*/
|
|
769
|
+
data: Prisma.EnabledModelCreateManyInput | Prisma.EnabledModelCreateManyInput[];
|
|
770
|
+
skipDuplicates?: boolean;
|
|
771
|
+
};
|
|
772
|
+
/**
|
|
773
|
+
* EnabledModel createManyAndReturn
|
|
774
|
+
*/
|
|
775
|
+
export type EnabledModelCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
776
|
+
/**
|
|
777
|
+
* Select specific fields to fetch from the EnabledModel
|
|
778
|
+
*/
|
|
779
|
+
select?: Prisma.EnabledModelSelectCreateManyAndReturn<ExtArgs> | null;
|
|
780
|
+
/**
|
|
781
|
+
* Omit specific fields from the EnabledModel
|
|
782
|
+
*/
|
|
783
|
+
omit?: Prisma.EnabledModelOmit<ExtArgs> | null;
|
|
784
|
+
/**
|
|
785
|
+
* The data used to create many EnabledModels.
|
|
786
|
+
*/
|
|
787
|
+
data: Prisma.EnabledModelCreateManyInput | Prisma.EnabledModelCreateManyInput[];
|
|
788
|
+
skipDuplicates?: boolean;
|
|
789
|
+
};
|
|
790
|
+
/**
|
|
791
|
+
* EnabledModel update
|
|
792
|
+
*/
|
|
793
|
+
export type EnabledModelUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
794
|
+
/**
|
|
795
|
+
* Select specific fields to fetch from the EnabledModel
|
|
796
|
+
*/
|
|
797
|
+
select?: Prisma.EnabledModelSelect<ExtArgs> | null;
|
|
798
|
+
/**
|
|
799
|
+
* Omit specific fields from the EnabledModel
|
|
800
|
+
*/
|
|
801
|
+
omit?: Prisma.EnabledModelOmit<ExtArgs> | null;
|
|
802
|
+
/**
|
|
803
|
+
* The data needed to update a EnabledModel.
|
|
804
|
+
*/
|
|
805
|
+
data: Prisma.XOR<Prisma.EnabledModelUpdateInput, Prisma.EnabledModelUncheckedUpdateInput>;
|
|
806
|
+
/**
|
|
807
|
+
* Choose, which EnabledModel to update.
|
|
808
|
+
*/
|
|
809
|
+
where: Prisma.EnabledModelWhereUniqueInput;
|
|
810
|
+
};
|
|
811
|
+
/**
|
|
812
|
+
* EnabledModel updateMany
|
|
813
|
+
*/
|
|
814
|
+
export type EnabledModelUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
815
|
+
/**
|
|
816
|
+
* The data used to update EnabledModels.
|
|
817
|
+
*/
|
|
818
|
+
data: Prisma.XOR<Prisma.EnabledModelUpdateManyMutationInput, Prisma.EnabledModelUncheckedUpdateManyInput>;
|
|
819
|
+
/**
|
|
820
|
+
* Filter which EnabledModels to update
|
|
821
|
+
*/
|
|
822
|
+
where?: Prisma.EnabledModelWhereInput;
|
|
823
|
+
/**
|
|
824
|
+
* Limit how many EnabledModels to update.
|
|
825
|
+
*/
|
|
826
|
+
limit?: number;
|
|
827
|
+
};
|
|
828
|
+
/**
|
|
829
|
+
* EnabledModel updateManyAndReturn
|
|
830
|
+
*/
|
|
831
|
+
export type EnabledModelUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
832
|
+
/**
|
|
833
|
+
* Select specific fields to fetch from the EnabledModel
|
|
834
|
+
*/
|
|
835
|
+
select?: Prisma.EnabledModelSelectUpdateManyAndReturn<ExtArgs> | null;
|
|
836
|
+
/**
|
|
837
|
+
* Omit specific fields from the EnabledModel
|
|
838
|
+
*/
|
|
839
|
+
omit?: Prisma.EnabledModelOmit<ExtArgs> | null;
|
|
840
|
+
/**
|
|
841
|
+
* The data used to update EnabledModels.
|
|
842
|
+
*/
|
|
843
|
+
data: Prisma.XOR<Prisma.EnabledModelUpdateManyMutationInput, Prisma.EnabledModelUncheckedUpdateManyInput>;
|
|
844
|
+
/**
|
|
845
|
+
* Filter which EnabledModels to update
|
|
846
|
+
*/
|
|
847
|
+
where?: Prisma.EnabledModelWhereInput;
|
|
848
|
+
/**
|
|
849
|
+
* Limit how many EnabledModels to update.
|
|
850
|
+
*/
|
|
851
|
+
limit?: number;
|
|
852
|
+
};
|
|
853
|
+
/**
|
|
854
|
+
* EnabledModel upsert
|
|
855
|
+
*/
|
|
856
|
+
export type EnabledModelUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
857
|
+
/**
|
|
858
|
+
* Select specific fields to fetch from the EnabledModel
|
|
859
|
+
*/
|
|
860
|
+
select?: Prisma.EnabledModelSelect<ExtArgs> | null;
|
|
861
|
+
/**
|
|
862
|
+
* Omit specific fields from the EnabledModel
|
|
863
|
+
*/
|
|
864
|
+
omit?: Prisma.EnabledModelOmit<ExtArgs> | null;
|
|
865
|
+
/**
|
|
866
|
+
* The filter to search for the EnabledModel to update in case it exists.
|
|
867
|
+
*/
|
|
868
|
+
where: Prisma.EnabledModelWhereUniqueInput;
|
|
869
|
+
/**
|
|
870
|
+
* In case the EnabledModel found by the `where` argument doesn't exist, create a new EnabledModel with this data.
|
|
871
|
+
*/
|
|
872
|
+
create: Prisma.XOR<Prisma.EnabledModelCreateInput, Prisma.EnabledModelUncheckedCreateInput>;
|
|
873
|
+
/**
|
|
874
|
+
* In case the EnabledModel was found with the provided `where` argument, update it with this data.
|
|
875
|
+
*/
|
|
876
|
+
update: Prisma.XOR<Prisma.EnabledModelUpdateInput, Prisma.EnabledModelUncheckedUpdateInput>;
|
|
877
|
+
};
|
|
878
|
+
/**
|
|
879
|
+
* EnabledModel delete
|
|
880
|
+
*/
|
|
881
|
+
export type EnabledModelDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
882
|
+
/**
|
|
883
|
+
* Select specific fields to fetch from the EnabledModel
|
|
884
|
+
*/
|
|
885
|
+
select?: Prisma.EnabledModelSelect<ExtArgs> | null;
|
|
886
|
+
/**
|
|
887
|
+
* Omit specific fields from the EnabledModel
|
|
888
|
+
*/
|
|
889
|
+
omit?: Prisma.EnabledModelOmit<ExtArgs> | null;
|
|
890
|
+
/**
|
|
891
|
+
* Filter which EnabledModel to delete.
|
|
892
|
+
*/
|
|
893
|
+
where: Prisma.EnabledModelWhereUniqueInput;
|
|
894
|
+
};
|
|
895
|
+
/**
|
|
896
|
+
* EnabledModel deleteMany
|
|
897
|
+
*/
|
|
898
|
+
export type EnabledModelDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
899
|
+
/**
|
|
900
|
+
* Filter which EnabledModels to delete
|
|
901
|
+
*/
|
|
902
|
+
where?: Prisma.EnabledModelWhereInput;
|
|
903
|
+
/**
|
|
904
|
+
* Limit how many EnabledModels to delete.
|
|
905
|
+
*/
|
|
906
|
+
limit?: number;
|
|
907
|
+
};
|
|
908
|
+
/**
|
|
909
|
+
* EnabledModel without action
|
|
910
|
+
*/
|
|
911
|
+
export type EnabledModelDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
912
|
+
/**
|
|
913
|
+
* Select specific fields to fetch from the EnabledModel
|
|
914
|
+
*/
|
|
915
|
+
select?: Prisma.EnabledModelSelect<ExtArgs> | null;
|
|
916
|
+
/**
|
|
917
|
+
* Omit specific fields from the EnabledModel
|
|
918
|
+
*/
|
|
919
|
+
omit?: Prisma.EnabledModelOmit<ExtArgs> | null;
|
|
920
|
+
};
|