@aeolus-fleet/trierarch-plugin 0.32.0 → 0.34.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/adapters/fleet/operator-fleet.d.ts +2 -0
- package/dist/adapters/fleet/operator-fleet.js +50 -0
- package/dist/adapters/fleet/operator-fleet.js.map +1 -0
- package/dist/adapters/fleet/rest-fleet-door.js +2 -1
- package/dist/adapters/fleet/rest-fleet-door.js.map +1 -1
- 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 +23 -0
- package/dist/adapters/prisma/generated/client.d.ts +23 -0
- package/dist/adapters/prisma/generated/commonInputTypes.d.ts +201 -0
- package/dist/adapters/prisma/generated/internal/class.d.ts +33 -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 +306 -1
- package/dist/adapters/prisma/generated/internal/prismaNamespace.js +54 -1
- package/dist/adapters/prisma/generated/internal/prismaNamespace.js.map +1 -1
- package/dist/adapters/prisma/generated/internal/prismaNamespaceBrowser.d.ts +56 -0
- package/dist/adapters/prisma/generated/internal/prismaNamespaceBrowser.js +54 -1
- package/dist/adapters/prisma/generated/internal/prismaNamespaceBrowser.js.map +1 -1
- package/dist/adapters/prisma/generated/models/SubscriptionReading.d.ts +1113 -0
- package/dist/adapters/prisma/generated/models/SubscriptionReading.js +2 -0
- package/dist/adapters/prisma/generated/models/SubscriptionReading.js.map +1 -0
- package/dist/adapters/prisma/generated/models/UsageDay.d.ts +1554 -0
- package/dist/adapters/prisma/generated/models/UsageDay.js +2 -0
- package/dist/adapters/prisma/generated/models/UsageDay.js.map +1 -0
- package/dist/adapters/prisma/generated/models/UsageHour.d.ts +1445 -0
- package/dist/adapters/prisma/generated/models/UsageHour.js +2 -0
- package/dist/adapters/prisma/generated/models/UsageHour.js.map +1 -0
- package/dist/adapters/prisma/generated/models.d.ts +3 -0
- package/dist/adapters/prisma/usage-history.d.ts +3 -0
- package/dist/adapters/prisma/usage-history.js +316 -0
- package/dist/adapters/prisma/usage-history.js.map +1 -0
- package/dist/adapters/trpc/router.d.ts +225 -1
- package/dist/adapters/trpc/router.js +185 -1
- package/dist/adapters/trpc/router.js.map +1 -1
- package/dist/app.js +16 -0
- package/dist/app.js.map +1 -1
- package/dist/core/connection/ports.d.ts +1 -0
- package/dist/core/machines/join-machine.js +2 -4
- package/dist/core/machines/join-machine.js.map +1 -1
- package/dist/core/machines/new-setup-line.d.ts +32 -0
- package/dist/core/machines/new-setup-line.js +45 -0
- package/dist/core/machines/new-setup-line.js.map +1 -0
- package/dist/core/machines/setup-line.d.ts +14 -0
- package/dist/core/machines/setup-line.js +13 -0
- package/dist/core/machines/setup-line.js.map +1 -0
- package/dist/core/operator/ports.d.ts +27 -2
- package/dist/core/shared/errors.d.ts +1 -1
- package/dist/core/shared/errors.js.map +1 -1
- package/dist/core/usage/ports.d.ts +19 -0
- package/dist/core/usage/ports.js +2 -0
- package/dist/core/usage/ports.js.map +1 -0
- package/dist/core/usage/read-subscription-windows.d.ts +35 -0
- package/dist/core/usage/read-subscription-windows.js +32 -0
- package/dist/core/usage/read-subscription-windows.js.map +1 -0
- package/dist/core/usage/read-token-usage.d.ts +61 -0
- package/dist/core/usage/read-token-usage.js +79 -0
- package/dist/core/usage/read-token-usage.js.map +1 -0
- package/dist/core/usage/read-usage-values.d.ts +36 -0
- package/dist/core/usage/read-usage-values.js +31 -0
- package/dist/core/usage/read-usage-values.js.map +1 -0
- package/dist/core/usage/ship-names.d.ts +19 -0
- package/dist/core/usage/ship-names.js +29 -0
- package/dist/core/usage/ship-names.js.map +1 -0
- package/dist/core/usage/subscription-windows.d.ts +28 -0
- package/dist/core/usage/subscription-windows.js +2 -0
- package/dist/core/usage/subscription-windows.js.map +1 -0
- package/dist/core/usage/token-usage.d.ts +61 -0
- package/dist/core/usage/token-usage.js +5 -0
- package/dist/core/usage/token-usage.js.map +1 -0
- package/dist/core/usage/usage-range.d.ts +12 -0
- package/dist/core/usage/usage-range.js +24 -0
- package/dist/core/usage/usage-range.js.map +1 -0
- package/dist/core/usage/usage-reading.d.ts +53 -0
- package/dist/core/usage/usage-reading.js +2 -0
- package/dist/core/usage/usage-reading.js.map +1 -0
- package/dist/core/usage/usage-values.d.ts +15 -0
- package/dist/core/usage/usage-values.js +2 -0
- package/dist/core/usage/usage-values.js.map +1 -0
- package/package.json +1 -1
- package/src/adapters/prisma/migrations/20261028120000_usage_history/migration.sql +57 -0
- package/src/adapters/prisma/migrations/20261028150000_usage_cost_per_kind/migration.sql +21 -0
- package/src/adapters/prisma/schema.prisma +79 -2
|
@@ -0,0 +1,1554 @@
|
|
|
1
|
+
import type * as runtime from "@prisma/client/runtime/client";
|
|
2
|
+
import type * as Prisma from "../internal/prismaNamespace.js";
|
|
3
|
+
/**
|
|
4
|
+
* Model UsageDay
|
|
5
|
+
* The hours of one UTC day added up, per machine, ship, model, harness and
|
|
6
|
+
* login: the rollup ranges over 7 days read. Written in the same transaction as
|
|
7
|
+
* each usage_hours row, by the difference between the new and the stored row.
|
|
8
|
+
* Its key holds the login, which may be null, so the migration makes that
|
|
9
|
+
* unique index NULLS NOT DISTINCT, which this schema cannot say.
|
|
10
|
+
*/
|
|
11
|
+
export type UsageDayModel = runtime.Types.Result.DefaultSelection<Prisma.$UsageDayPayload>;
|
|
12
|
+
export type AggregateUsageDay = {
|
|
13
|
+
_count: UsageDayCountAggregateOutputType | null;
|
|
14
|
+
_avg: UsageDayAvgAggregateOutputType | null;
|
|
15
|
+
_sum: UsageDaySumAggregateOutputType | null;
|
|
16
|
+
_min: UsageDayMinAggregateOutputType | null;
|
|
17
|
+
_max: UsageDayMaxAggregateOutputType | null;
|
|
18
|
+
};
|
|
19
|
+
export type UsageDayAvgAggregateOutputType = {
|
|
20
|
+
id: number | null;
|
|
21
|
+
input: number | null;
|
|
22
|
+
output: number | null;
|
|
23
|
+
cacheRead: number | null;
|
|
24
|
+
cacheWrite: number | null;
|
|
25
|
+
estimatedCostInputUsd: runtime.Decimal | null;
|
|
26
|
+
estimatedCostOutputUsd: runtime.Decimal | null;
|
|
27
|
+
estimatedCostCacheReadUsd: runtime.Decimal | null;
|
|
28
|
+
estimatedCostCacheWriteUsd: runtime.Decimal | null;
|
|
29
|
+
unpricedInput: number | null;
|
|
30
|
+
unpricedOutput: number | null;
|
|
31
|
+
unpricedCacheRead: number | null;
|
|
32
|
+
unpricedCacheWrite: number | null;
|
|
33
|
+
};
|
|
34
|
+
export type UsageDaySumAggregateOutputType = {
|
|
35
|
+
id: bigint | null;
|
|
36
|
+
input: bigint | null;
|
|
37
|
+
output: bigint | null;
|
|
38
|
+
cacheRead: bigint | null;
|
|
39
|
+
cacheWrite: bigint | null;
|
|
40
|
+
estimatedCostInputUsd: runtime.Decimal | null;
|
|
41
|
+
estimatedCostOutputUsd: runtime.Decimal | null;
|
|
42
|
+
estimatedCostCacheReadUsd: runtime.Decimal | null;
|
|
43
|
+
estimatedCostCacheWriteUsd: runtime.Decimal | null;
|
|
44
|
+
unpricedInput: bigint | null;
|
|
45
|
+
unpricedOutput: bigint | null;
|
|
46
|
+
unpricedCacheRead: bigint | null;
|
|
47
|
+
unpricedCacheWrite: bigint | null;
|
|
48
|
+
};
|
|
49
|
+
export type UsageDayMinAggregateOutputType = {
|
|
50
|
+
id: bigint | null;
|
|
51
|
+
fleetId: string | null;
|
|
52
|
+
day: Date | null;
|
|
53
|
+
machineShipId: string | null;
|
|
54
|
+
shipId: string | null;
|
|
55
|
+
model: string | null;
|
|
56
|
+
harness: string | null;
|
|
57
|
+
login: string | null;
|
|
58
|
+
input: bigint | null;
|
|
59
|
+
output: bigint | null;
|
|
60
|
+
cacheRead: bigint | null;
|
|
61
|
+
cacheWrite: bigint | null;
|
|
62
|
+
estimatedCostInputUsd: runtime.Decimal | null;
|
|
63
|
+
estimatedCostOutputUsd: runtime.Decimal | null;
|
|
64
|
+
estimatedCostCacheReadUsd: runtime.Decimal | null;
|
|
65
|
+
estimatedCostCacheWriteUsd: runtime.Decimal | null;
|
|
66
|
+
unpricedInput: bigint | null;
|
|
67
|
+
unpricedOutput: bigint | null;
|
|
68
|
+
unpricedCacheRead: bigint | null;
|
|
69
|
+
unpricedCacheWrite: bigint | null;
|
|
70
|
+
};
|
|
71
|
+
export type UsageDayMaxAggregateOutputType = {
|
|
72
|
+
id: bigint | null;
|
|
73
|
+
fleetId: string | null;
|
|
74
|
+
day: Date | null;
|
|
75
|
+
machineShipId: string | null;
|
|
76
|
+
shipId: string | null;
|
|
77
|
+
model: string | null;
|
|
78
|
+
harness: string | null;
|
|
79
|
+
login: string | null;
|
|
80
|
+
input: bigint | null;
|
|
81
|
+
output: bigint | null;
|
|
82
|
+
cacheRead: bigint | null;
|
|
83
|
+
cacheWrite: bigint | null;
|
|
84
|
+
estimatedCostInputUsd: runtime.Decimal | null;
|
|
85
|
+
estimatedCostOutputUsd: runtime.Decimal | null;
|
|
86
|
+
estimatedCostCacheReadUsd: runtime.Decimal | null;
|
|
87
|
+
estimatedCostCacheWriteUsd: runtime.Decimal | null;
|
|
88
|
+
unpricedInput: bigint | null;
|
|
89
|
+
unpricedOutput: bigint | null;
|
|
90
|
+
unpricedCacheRead: bigint | null;
|
|
91
|
+
unpricedCacheWrite: bigint | null;
|
|
92
|
+
};
|
|
93
|
+
export type UsageDayCountAggregateOutputType = {
|
|
94
|
+
id: number;
|
|
95
|
+
fleetId: number;
|
|
96
|
+
day: number;
|
|
97
|
+
machineShipId: number;
|
|
98
|
+
shipId: number;
|
|
99
|
+
model: number;
|
|
100
|
+
harness: number;
|
|
101
|
+
login: number;
|
|
102
|
+
input: number;
|
|
103
|
+
output: number;
|
|
104
|
+
cacheRead: number;
|
|
105
|
+
cacheWrite: number;
|
|
106
|
+
estimatedCostInputUsd: number;
|
|
107
|
+
estimatedCostOutputUsd: number;
|
|
108
|
+
estimatedCostCacheReadUsd: number;
|
|
109
|
+
estimatedCostCacheWriteUsd: number;
|
|
110
|
+
unpricedInput: number;
|
|
111
|
+
unpricedOutput: number;
|
|
112
|
+
unpricedCacheRead: number;
|
|
113
|
+
unpricedCacheWrite: number;
|
|
114
|
+
_all: number;
|
|
115
|
+
};
|
|
116
|
+
export type UsageDayAvgAggregateInputType = {
|
|
117
|
+
id?: true;
|
|
118
|
+
input?: true;
|
|
119
|
+
output?: true;
|
|
120
|
+
cacheRead?: true;
|
|
121
|
+
cacheWrite?: true;
|
|
122
|
+
estimatedCostInputUsd?: true;
|
|
123
|
+
estimatedCostOutputUsd?: true;
|
|
124
|
+
estimatedCostCacheReadUsd?: true;
|
|
125
|
+
estimatedCostCacheWriteUsd?: true;
|
|
126
|
+
unpricedInput?: true;
|
|
127
|
+
unpricedOutput?: true;
|
|
128
|
+
unpricedCacheRead?: true;
|
|
129
|
+
unpricedCacheWrite?: true;
|
|
130
|
+
};
|
|
131
|
+
export type UsageDaySumAggregateInputType = {
|
|
132
|
+
id?: true;
|
|
133
|
+
input?: true;
|
|
134
|
+
output?: true;
|
|
135
|
+
cacheRead?: true;
|
|
136
|
+
cacheWrite?: true;
|
|
137
|
+
estimatedCostInputUsd?: true;
|
|
138
|
+
estimatedCostOutputUsd?: true;
|
|
139
|
+
estimatedCostCacheReadUsd?: true;
|
|
140
|
+
estimatedCostCacheWriteUsd?: true;
|
|
141
|
+
unpricedInput?: true;
|
|
142
|
+
unpricedOutput?: true;
|
|
143
|
+
unpricedCacheRead?: true;
|
|
144
|
+
unpricedCacheWrite?: true;
|
|
145
|
+
};
|
|
146
|
+
export type UsageDayMinAggregateInputType = {
|
|
147
|
+
id?: true;
|
|
148
|
+
fleetId?: true;
|
|
149
|
+
day?: true;
|
|
150
|
+
machineShipId?: true;
|
|
151
|
+
shipId?: true;
|
|
152
|
+
model?: true;
|
|
153
|
+
harness?: true;
|
|
154
|
+
login?: true;
|
|
155
|
+
input?: true;
|
|
156
|
+
output?: true;
|
|
157
|
+
cacheRead?: true;
|
|
158
|
+
cacheWrite?: true;
|
|
159
|
+
estimatedCostInputUsd?: true;
|
|
160
|
+
estimatedCostOutputUsd?: true;
|
|
161
|
+
estimatedCostCacheReadUsd?: true;
|
|
162
|
+
estimatedCostCacheWriteUsd?: true;
|
|
163
|
+
unpricedInput?: true;
|
|
164
|
+
unpricedOutput?: true;
|
|
165
|
+
unpricedCacheRead?: true;
|
|
166
|
+
unpricedCacheWrite?: true;
|
|
167
|
+
};
|
|
168
|
+
export type UsageDayMaxAggregateInputType = {
|
|
169
|
+
id?: true;
|
|
170
|
+
fleetId?: true;
|
|
171
|
+
day?: true;
|
|
172
|
+
machineShipId?: true;
|
|
173
|
+
shipId?: true;
|
|
174
|
+
model?: true;
|
|
175
|
+
harness?: true;
|
|
176
|
+
login?: true;
|
|
177
|
+
input?: true;
|
|
178
|
+
output?: true;
|
|
179
|
+
cacheRead?: true;
|
|
180
|
+
cacheWrite?: true;
|
|
181
|
+
estimatedCostInputUsd?: true;
|
|
182
|
+
estimatedCostOutputUsd?: true;
|
|
183
|
+
estimatedCostCacheReadUsd?: true;
|
|
184
|
+
estimatedCostCacheWriteUsd?: true;
|
|
185
|
+
unpricedInput?: true;
|
|
186
|
+
unpricedOutput?: true;
|
|
187
|
+
unpricedCacheRead?: true;
|
|
188
|
+
unpricedCacheWrite?: true;
|
|
189
|
+
};
|
|
190
|
+
export type UsageDayCountAggregateInputType = {
|
|
191
|
+
id?: true;
|
|
192
|
+
fleetId?: true;
|
|
193
|
+
day?: true;
|
|
194
|
+
machineShipId?: true;
|
|
195
|
+
shipId?: true;
|
|
196
|
+
model?: true;
|
|
197
|
+
harness?: true;
|
|
198
|
+
login?: true;
|
|
199
|
+
input?: true;
|
|
200
|
+
output?: true;
|
|
201
|
+
cacheRead?: true;
|
|
202
|
+
cacheWrite?: true;
|
|
203
|
+
estimatedCostInputUsd?: true;
|
|
204
|
+
estimatedCostOutputUsd?: true;
|
|
205
|
+
estimatedCostCacheReadUsd?: true;
|
|
206
|
+
estimatedCostCacheWriteUsd?: true;
|
|
207
|
+
unpricedInput?: true;
|
|
208
|
+
unpricedOutput?: true;
|
|
209
|
+
unpricedCacheRead?: true;
|
|
210
|
+
unpricedCacheWrite?: true;
|
|
211
|
+
_all?: true;
|
|
212
|
+
};
|
|
213
|
+
export type UsageDayAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
214
|
+
/**
|
|
215
|
+
* Filter which UsageDay to aggregate.
|
|
216
|
+
*/
|
|
217
|
+
where?: Prisma.UsageDayWhereInput;
|
|
218
|
+
/**
|
|
219
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
220
|
+
*
|
|
221
|
+
* Determine the order of UsageDays to fetch.
|
|
222
|
+
*/
|
|
223
|
+
orderBy?: Prisma.UsageDayOrderByWithRelationInput | Prisma.UsageDayOrderByWithRelationInput[];
|
|
224
|
+
/**
|
|
225
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
226
|
+
*
|
|
227
|
+
* Sets the start position
|
|
228
|
+
*/
|
|
229
|
+
cursor?: Prisma.UsageDayWhereUniqueInput;
|
|
230
|
+
/**
|
|
231
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
232
|
+
*
|
|
233
|
+
* Take `±n` UsageDays from the position of the cursor.
|
|
234
|
+
*/
|
|
235
|
+
take?: number;
|
|
236
|
+
/**
|
|
237
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
238
|
+
*
|
|
239
|
+
* Skip the first `n` UsageDays.
|
|
240
|
+
*/
|
|
241
|
+
skip?: number;
|
|
242
|
+
/**
|
|
243
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
244
|
+
*
|
|
245
|
+
* Count returned UsageDays
|
|
246
|
+
**/
|
|
247
|
+
_count?: true | UsageDayCountAggregateInputType;
|
|
248
|
+
/**
|
|
249
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
250
|
+
*
|
|
251
|
+
* Select which fields to average
|
|
252
|
+
**/
|
|
253
|
+
_avg?: UsageDayAvgAggregateInputType;
|
|
254
|
+
/**
|
|
255
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
256
|
+
*
|
|
257
|
+
* Select which fields to sum
|
|
258
|
+
**/
|
|
259
|
+
_sum?: UsageDaySumAggregateInputType;
|
|
260
|
+
/**
|
|
261
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
262
|
+
*
|
|
263
|
+
* Select which fields to find the minimum value
|
|
264
|
+
**/
|
|
265
|
+
_min?: UsageDayMinAggregateInputType;
|
|
266
|
+
/**
|
|
267
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
268
|
+
*
|
|
269
|
+
* Select which fields to find the maximum value
|
|
270
|
+
**/
|
|
271
|
+
_max?: UsageDayMaxAggregateInputType;
|
|
272
|
+
};
|
|
273
|
+
export type GetUsageDayAggregateType<T extends UsageDayAggregateArgs> = {
|
|
274
|
+
[P in keyof T & keyof AggregateUsageDay]: P extends '_count' | 'count' ? T[P] extends true ? number : Prisma.GetScalarType<T[P], AggregateUsageDay[P]> : Prisma.GetScalarType<T[P], AggregateUsageDay[P]>;
|
|
275
|
+
};
|
|
276
|
+
export type UsageDayGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
277
|
+
where?: Prisma.UsageDayWhereInput;
|
|
278
|
+
orderBy?: Prisma.UsageDayOrderByWithAggregationInput | Prisma.UsageDayOrderByWithAggregationInput[];
|
|
279
|
+
by: Prisma.UsageDayScalarFieldEnum[] | Prisma.UsageDayScalarFieldEnum;
|
|
280
|
+
having?: Prisma.UsageDayScalarWhereWithAggregatesInput;
|
|
281
|
+
take?: number;
|
|
282
|
+
skip?: number;
|
|
283
|
+
_count?: UsageDayCountAggregateInputType | true;
|
|
284
|
+
_avg?: UsageDayAvgAggregateInputType;
|
|
285
|
+
_sum?: UsageDaySumAggregateInputType;
|
|
286
|
+
_min?: UsageDayMinAggregateInputType;
|
|
287
|
+
_max?: UsageDayMaxAggregateInputType;
|
|
288
|
+
};
|
|
289
|
+
export type UsageDayGroupByOutputType = {
|
|
290
|
+
id: bigint;
|
|
291
|
+
fleetId: string;
|
|
292
|
+
day: Date;
|
|
293
|
+
machineShipId: string;
|
|
294
|
+
shipId: string;
|
|
295
|
+
model: string;
|
|
296
|
+
harness: string;
|
|
297
|
+
login: string | null;
|
|
298
|
+
input: bigint;
|
|
299
|
+
output: bigint;
|
|
300
|
+
cacheRead: bigint;
|
|
301
|
+
cacheWrite: bigint;
|
|
302
|
+
estimatedCostInputUsd: runtime.Decimal;
|
|
303
|
+
estimatedCostOutputUsd: runtime.Decimal;
|
|
304
|
+
estimatedCostCacheReadUsd: runtime.Decimal;
|
|
305
|
+
estimatedCostCacheWriteUsd: runtime.Decimal;
|
|
306
|
+
unpricedInput: bigint;
|
|
307
|
+
unpricedOutput: bigint;
|
|
308
|
+
unpricedCacheRead: bigint;
|
|
309
|
+
unpricedCacheWrite: bigint;
|
|
310
|
+
_count: UsageDayCountAggregateOutputType | null;
|
|
311
|
+
_avg: UsageDayAvgAggregateOutputType | null;
|
|
312
|
+
_sum: UsageDaySumAggregateOutputType | null;
|
|
313
|
+
_min: UsageDayMinAggregateOutputType | null;
|
|
314
|
+
_max: UsageDayMaxAggregateOutputType | null;
|
|
315
|
+
};
|
|
316
|
+
export type GetUsageDayGroupByPayload<T extends UsageDayGroupByArgs> = Prisma.PrismaPromise<Array<Prisma.PickEnumerable<UsageDayGroupByOutputType, T['by']> & {
|
|
317
|
+
[P in ((keyof T) & (keyof UsageDayGroupByOutputType))]: P extends '_count' ? T[P] extends boolean ? number : Prisma.GetScalarType<T[P], UsageDayGroupByOutputType[P]> : Prisma.GetScalarType<T[P], UsageDayGroupByOutputType[P]>;
|
|
318
|
+
}>>;
|
|
319
|
+
export type UsageDayWhereInput = {
|
|
320
|
+
AND?: Prisma.UsageDayWhereInput | Prisma.UsageDayWhereInput[];
|
|
321
|
+
OR?: Prisma.UsageDayWhereInput[];
|
|
322
|
+
NOT?: Prisma.UsageDayWhereInput | Prisma.UsageDayWhereInput[];
|
|
323
|
+
id?: Prisma.BigIntFilter<"UsageDay"> | bigint | number;
|
|
324
|
+
fleetId?: Prisma.StringFilter<"UsageDay"> | string;
|
|
325
|
+
day?: Prisma.DateTimeFilter<"UsageDay"> | Date | string;
|
|
326
|
+
machineShipId?: Prisma.StringFilter<"UsageDay"> | string;
|
|
327
|
+
shipId?: Prisma.StringFilter<"UsageDay"> | string;
|
|
328
|
+
model?: Prisma.StringFilter<"UsageDay"> | string;
|
|
329
|
+
harness?: Prisma.StringFilter<"UsageDay"> | string;
|
|
330
|
+
login?: Prisma.StringNullableFilter<"UsageDay"> | string | null;
|
|
331
|
+
input?: Prisma.BigIntFilter<"UsageDay"> | bigint | number;
|
|
332
|
+
output?: Prisma.BigIntFilter<"UsageDay"> | bigint | number;
|
|
333
|
+
cacheRead?: Prisma.BigIntFilter<"UsageDay"> | bigint | number;
|
|
334
|
+
cacheWrite?: Prisma.BigIntFilter<"UsageDay"> | bigint | number;
|
|
335
|
+
estimatedCostInputUsd?: Prisma.DecimalFilter<"UsageDay"> | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
336
|
+
estimatedCostOutputUsd?: Prisma.DecimalFilter<"UsageDay"> | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
337
|
+
estimatedCostCacheReadUsd?: Prisma.DecimalFilter<"UsageDay"> | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
338
|
+
estimatedCostCacheWriteUsd?: Prisma.DecimalFilter<"UsageDay"> | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
339
|
+
unpricedInput?: Prisma.BigIntFilter<"UsageDay"> | bigint | number;
|
|
340
|
+
unpricedOutput?: Prisma.BigIntFilter<"UsageDay"> | bigint | number;
|
|
341
|
+
unpricedCacheRead?: Prisma.BigIntFilter<"UsageDay"> | bigint | number;
|
|
342
|
+
unpricedCacheWrite?: Prisma.BigIntFilter<"UsageDay"> | bigint | number;
|
|
343
|
+
};
|
|
344
|
+
export type UsageDayOrderByWithRelationInput = {
|
|
345
|
+
id?: Prisma.SortOrder;
|
|
346
|
+
fleetId?: Prisma.SortOrder;
|
|
347
|
+
day?: Prisma.SortOrder;
|
|
348
|
+
machineShipId?: Prisma.SortOrder;
|
|
349
|
+
shipId?: Prisma.SortOrder;
|
|
350
|
+
model?: Prisma.SortOrder;
|
|
351
|
+
harness?: Prisma.SortOrder;
|
|
352
|
+
login?: Prisma.SortOrderInput | Prisma.SortOrder;
|
|
353
|
+
input?: Prisma.SortOrder;
|
|
354
|
+
output?: Prisma.SortOrder;
|
|
355
|
+
cacheRead?: Prisma.SortOrder;
|
|
356
|
+
cacheWrite?: Prisma.SortOrder;
|
|
357
|
+
estimatedCostInputUsd?: Prisma.SortOrder;
|
|
358
|
+
estimatedCostOutputUsd?: Prisma.SortOrder;
|
|
359
|
+
estimatedCostCacheReadUsd?: Prisma.SortOrder;
|
|
360
|
+
estimatedCostCacheWriteUsd?: Prisma.SortOrder;
|
|
361
|
+
unpricedInput?: Prisma.SortOrder;
|
|
362
|
+
unpricedOutput?: Prisma.SortOrder;
|
|
363
|
+
unpricedCacheRead?: Prisma.SortOrder;
|
|
364
|
+
unpricedCacheWrite?: Prisma.SortOrder;
|
|
365
|
+
};
|
|
366
|
+
export type UsageDayWhereUniqueInput = Prisma.AtLeast<{
|
|
367
|
+
id?: bigint | number;
|
|
368
|
+
fleetId_day_machineShipId_shipId_model_harness_login?: Prisma.UsageDayFleetIdDayMachineShipIdShipIdModelHarnessLoginCompoundUniqueInput;
|
|
369
|
+
AND?: Prisma.UsageDayWhereInput | Prisma.UsageDayWhereInput[];
|
|
370
|
+
OR?: Prisma.UsageDayWhereInput[];
|
|
371
|
+
NOT?: Prisma.UsageDayWhereInput | Prisma.UsageDayWhereInput[];
|
|
372
|
+
fleetId?: Prisma.StringFilter<"UsageDay"> | string;
|
|
373
|
+
day?: Prisma.DateTimeFilter<"UsageDay"> | Date | string;
|
|
374
|
+
machineShipId?: Prisma.StringFilter<"UsageDay"> | string;
|
|
375
|
+
shipId?: Prisma.StringFilter<"UsageDay"> | string;
|
|
376
|
+
model?: Prisma.StringFilter<"UsageDay"> | string;
|
|
377
|
+
harness?: Prisma.StringFilter<"UsageDay"> | string;
|
|
378
|
+
login?: Prisma.StringNullableFilter<"UsageDay"> | string | null;
|
|
379
|
+
input?: Prisma.BigIntFilter<"UsageDay"> | bigint | number;
|
|
380
|
+
output?: Prisma.BigIntFilter<"UsageDay"> | bigint | number;
|
|
381
|
+
cacheRead?: Prisma.BigIntFilter<"UsageDay"> | bigint | number;
|
|
382
|
+
cacheWrite?: Prisma.BigIntFilter<"UsageDay"> | bigint | number;
|
|
383
|
+
estimatedCostInputUsd?: Prisma.DecimalFilter<"UsageDay"> | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
384
|
+
estimatedCostOutputUsd?: Prisma.DecimalFilter<"UsageDay"> | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
385
|
+
estimatedCostCacheReadUsd?: Prisma.DecimalFilter<"UsageDay"> | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
386
|
+
estimatedCostCacheWriteUsd?: Prisma.DecimalFilter<"UsageDay"> | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
387
|
+
unpricedInput?: Prisma.BigIntFilter<"UsageDay"> | bigint | number;
|
|
388
|
+
unpricedOutput?: Prisma.BigIntFilter<"UsageDay"> | bigint | number;
|
|
389
|
+
unpricedCacheRead?: Prisma.BigIntFilter<"UsageDay"> | bigint | number;
|
|
390
|
+
unpricedCacheWrite?: Prisma.BigIntFilter<"UsageDay"> | bigint | number;
|
|
391
|
+
}, "id" | "fleetId_day_machineShipId_shipId_model_harness_login">;
|
|
392
|
+
export type UsageDayOrderByWithAggregationInput = {
|
|
393
|
+
id?: Prisma.SortOrder;
|
|
394
|
+
fleetId?: Prisma.SortOrder;
|
|
395
|
+
day?: Prisma.SortOrder;
|
|
396
|
+
machineShipId?: Prisma.SortOrder;
|
|
397
|
+
shipId?: Prisma.SortOrder;
|
|
398
|
+
model?: Prisma.SortOrder;
|
|
399
|
+
harness?: Prisma.SortOrder;
|
|
400
|
+
login?: Prisma.SortOrderInput | Prisma.SortOrder;
|
|
401
|
+
input?: Prisma.SortOrder;
|
|
402
|
+
output?: Prisma.SortOrder;
|
|
403
|
+
cacheRead?: Prisma.SortOrder;
|
|
404
|
+
cacheWrite?: Prisma.SortOrder;
|
|
405
|
+
estimatedCostInputUsd?: Prisma.SortOrder;
|
|
406
|
+
estimatedCostOutputUsd?: Prisma.SortOrder;
|
|
407
|
+
estimatedCostCacheReadUsd?: Prisma.SortOrder;
|
|
408
|
+
estimatedCostCacheWriteUsd?: Prisma.SortOrder;
|
|
409
|
+
unpricedInput?: Prisma.SortOrder;
|
|
410
|
+
unpricedOutput?: Prisma.SortOrder;
|
|
411
|
+
unpricedCacheRead?: Prisma.SortOrder;
|
|
412
|
+
unpricedCacheWrite?: Prisma.SortOrder;
|
|
413
|
+
_count?: Prisma.UsageDayCountOrderByAggregateInput;
|
|
414
|
+
_avg?: Prisma.UsageDayAvgOrderByAggregateInput;
|
|
415
|
+
_max?: Prisma.UsageDayMaxOrderByAggregateInput;
|
|
416
|
+
_min?: Prisma.UsageDayMinOrderByAggregateInput;
|
|
417
|
+
_sum?: Prisma.UsageDaySumOrderByAggregateInput;
|
|
418
|
+
};
|
|
419
|
+
export type UsageDayScalarWhereWithAggregatesInput = {
|
|
420
|
+
AND?: Prisma.UsageDayScalarWhereWithAggregatesInput | Prisma.UsageDayScalarWhereWithAggregatesInput[];
|
|
421
|
+
OR?: Prisma.UsageDayScalarWhereWithAggregatesInput[];
|
|
422
|
+
NOT?: Prisma.UsageDayScalarWhereWithAggregatesInput | Prisma.UsageDayScalarWhereWithAggregatesInput[];
|
|
423
|
+
id?: Prisma.BigIntWithAggregatesFilter<"UsageDay"> | bigint | number;
|
|
424
|
+
fleetId?: Prisma.StringWithAggregatesFilter<"UsageDay"> | string;
|
|
425
|
+
day?: Prisma.DateTimeWithAggregatesFilter<"UsageDay"> | Date | string;
|
|
426
|
+
machineShipId?: Prisma.StringWithAggregatesFilter<"UsageDay"> | string;
|
|
427
|
+
shipId?: Prisma.StringWithAggregatesFilter<"UsageDay"> | string;
|
|
428
|
+
model?: Prisma.StringWithAggregatesFilter<"UsageDay"> | string;
|
|
429
|
+
harness?: Prisma.StringWithAggregatesFilter<"UsageDay"> | string;
|
|
430
|
+
login?: Prisma.StringNullableWithAggregatesFilter<"UsageDay"> | string | null;
|
|
431
|
+
input?: Prisma.BigIntWithAggregatesFilter<"UsageDay"> | bigint | number;
|
|
432
|
+
output?: Prisma.BigIntWithAggregatesFilter<"UsageDay"> | bigint | number;
|
|
433
|
+
cacheRead?: Prisma.BigIntWithAggregatesFilter<"UsageDay"> | bigint | number;
|
|
434
|
+
cacheWrite?: Prisma.BigIntWithAggregatesFilter<"UsageDay"> | bigint | number;
|
|
435
|
+
estimatedCostInputUsd?: Prisma.DecimalWithAggregatesFilter<"UsageDay"> | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
436
|
+
estimatedCostOutputUsd?: Prisma.DecimalWithAggregatesFilter<"UsageDay"> | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
437
|
+
estimatedCostCacheReadUsd?: Prisma.DecimalWithAggregatesFilter<"UsageDay"> | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
438
|
+
estimatedCostCacheWriteUsd?: Prisma.DecimalWithAggregatesFilter<"UsageDay"> | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
439
|
+
unpricedInput?: Prisma.BigIntWithAggregatesFilter<"UsageDay"> | bigint | number;
|
|
440
|
+
unpricedOutput?: Prisma.BigIntWithAggregatesFilter<"UsageDay"> | bigint | number;
|
|
441
|
+
unpricedCacheRead?: Prisma.BigIntWithAggregatesFilter<"UsageDay"> | bigint | number;
|
|
442
|
+
unpricedCacheWrite?: Prisma.BigIntWithAggregatesFilter<"UsageDay"> | bigint | number;
|
|
443
|
+
};
|
|
444
|
+
export type UsageDayCreateInput = {
|
|
445
|
+
id?: bigint | number;
|
|
446
|
+
fleetId: string;
|
|
447
|
+
day: Date | string;
|
|
448
|
+
machineShipId: string;
|
|
449
|
+
shipId: string;
|
|
450
|
+
model: string;
|
|
451
|
+
harness: string;
|
|
452
|
+
login?: string | null;
|
|
453
|
+
input: bigint | number;
|
|
454
|
+
output: bigint | number;
|
|
455
|
+
cacheRead: bigint | number;
|
|
456
|
+
cacheWrite: bigint | number;
|
|
457
|
+
estimatedCostInputUsd: runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
458
|
+
estimatedCostOutputUsd: runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
459
|
+
estimatedCostCacheReadUsd: runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
460
|
+
estimatedCostCacheWriteUsd: runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
461
|
+
unpricedInput: bigint | number;
|
|
462
|
+
unpricedOutput: bigint | number;
|
|
463
|
+
unpricedCacheRead: bigint | number;
|
|
464
|
+
unpricedCacheWrite: bigint | number;
|
|
465
|
+
};
|
|
466
|
+
export type UsageDayUncheckedCreateInput = {
|
|
467
|
+
id?: bigint | number;
|
|
468
|
+
fleetId: string;
|
|
469
|
+
day: Date | string;
|
|
470
|
+
machineShipId: string;
|
|
471
|
+
shipId: string;
|
|
472
|
+
model: string;
|
|
473
|
+
harness: string;
|
|
474
|
+
login?: string | null;
|
|
475
|
+
input: bigint | number;
|
|
476
|
+
output: bigint | number;
|
|
477
|
+
cacheRead: bigint | number;
|
|
478
|
+
cacheWrite: bigint | number;
|
|
479
|
+
estimatedCostInputUsd: runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
480
|
+
estimatedCostOutputUsd: runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
481
|
+
estimatedCostCacheReadUsd: runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
482
|
+
estimatedCostCacheWriteUsd: runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
483
|
+
unpricedInput: bigint | number;
|
|
484
|
+
unpricedOutput: bigint | number;
|
|
485
|
+
unpricedCacheRead: bigint | number;
|
|
486
|
+
unpricedCacheWrite: bigint | number;
|
|
487
|
+
};
|
|
488
|
+
export type UsageDayUpdateInput = {
|
|
489
|
+
id?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
490
|
+
fleetId?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
491
|
+
day?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
492
|
+
machineShipId?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
493
|
+
shipId?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
494
|
+
model?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
495
|
+
harness?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
496
|
+
login?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
|
|
497
|
+
input?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
498
|
+
output?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
499
|
+
cacheRead?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
500
|
+
cacheWrite?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
501
|
+
estimatedCostInputUsd?: Prisma.DecimalFieldUpdateOperationsInput | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
502
|
+
estimatedCostOutputUsd?: Prisma.DecimalFieldUpdateOperationsInput | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
503
|
+
estimatedCostCacheReadUsd?: Prisma.DecimalFieldUpdateOperationsInput | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
504
|
+
estimatedCostCacheWriteUsd?: Prisma.DecimalFieldUpdateOperationsInput | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
505
|
+
unpricedInput?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
506
|
+
unpricedOutput?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
507
|
+
unpricedCacheRead?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
508
|
+
unpricedCacheWrite?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
509
|
+
};
|
|
510
|
+
export type UsageDayUncheckedUpdateInput = {
|
|
511
|
+
id?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
512
|
+
fleetId?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
513
|
+
day?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
514
|
+
machineShipId?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
515
|
+
shipId?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
516
|
+
model?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
517
|
+
harness?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
518
|
+
login?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
|
|
519
|
+
input?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
520
|
+
output?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
521
|
+
cacheRead?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
522
|
+
cacheWrite?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
523
|
+
estimatedCostInputUsd?: Prisma.DecimalFieldUpdateOperationsInput | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
524
|
+
estimatedCostOutputUsd?: Prisma.DecimalFieldUpdateOperationsInput | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
525
|
+
estimatedCostCacheReadUsd?: Prisma.DecimalFieldUpdateOperationsInput | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
526
|
+
estimatedCostCacheWriteUsd?: Prisma.DecimalFieldUpdateOperationsInput | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
527
|
+
unpricedInput?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
528
|
+
unpricedOutput?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
529
|
+
unpricedCacheRead?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
530
|
+
unpricedCacheWrite?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
531
|
+
};
|
|
532
|
+
export type UsageDayCreateManyInput = {
|
|
533
|
+
id?: bigint | number;
|
|
534
|
+
fleetId: string;
|
|
535
|
+
day: Date | string;
|
|
536
|
+
machineShipId: string;
|
|
537
|
+
shipId: string;
|
|
538
|
+
model: string;
|
|
539
|
+
harness: string;
|
|
540
|
+
login?: string | null;
|
|
541
|
+
input: bigint | number;
|
|
542
|
+
output: bigint | number;
|
|
543
|
+
cacheRead: bigint | number;
|
|
544
|
+
cacheWrite: bigint | number;
|
|
545
|
+
estimatedCostInputUsd: runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
546
|
+
estimatedCostOutputUsd: runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
547
|
+
estimatedCostCacheReadUsd: runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
548
|
+
estimatedCostCacheWriteUsd: runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
549
|
+
unpricedInput: bigint | number;
|
|
550
|
+
unpricedOutput: bigint | number;
|
|
551
|
+
unpricedCacheRead: bigint | number;
|
|
552
|
+
unpricedCacheWrite: bigint | number;
|
|
553
|
+
};
|
|
554
|
+
export type UsageDayUpdateManyMutationInput = {
|
|
555
|
+
id?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
556
|
+
fleetId?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
557
|
+
day?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
558
|
+
machineShipId?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
559
|
+
shipId?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
560
|
+
model?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
561
|
+
harness?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
562
|
+
login?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
|
|
563
|
+
input?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
564
|
+
output?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
565
|
+
cacheRead?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
566
|
+
cacheWrite?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
567
|
+
estimatedCostInputUsd?: Prisma.DecimalFieldUpdateOperationsInput | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
568
|
+
estimatedCostOutputUsd?: Prisma.DecimalFieldUpdateOperationsInput | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
569
|
+
estimatedCostCacheReadUsd?: Prisma.DecimalFieldUpdateOperationsInput | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
570
|
+
estimatedCostCacheWriteUsd?: Prisma.DecimalFieldUpdateOperationsInput | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
571
|
+
unpricedInput?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
572
|
+
unpricedOutput?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
573
|
+
unpricedCacheRead?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
574
|
+
unpricedCacheWrite?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
575
|
+
};
|
|
576
|
+
export type UsageDayUncheckedUpdateManyInput = {
|
|
577
|
+
id?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
578
|
+
fleetId?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
579
|
+
day?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
|
|
580
|
+
machineShipId?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
581
|
+
shipId?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
582
|
+
model?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
583
|
+
harness?: Prisma.StringFieldUpdateOperationsInput | string;
|
|
584
|
+
login?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
|
|
585
|
+
input?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
586
|
+
output?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
587
|
+
cacheRead?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
588
|
+
cacheWrite?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
589
|
+
estimatedCostInputUsd?: Prisma.DecimalFieldUpdateOperationsInput | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
590
|
+
estimatedCostOutputUsd?: Prisma.DecimalFieldUpdateOperationsInput | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
591
|
+
estimatedCostCacheReadUsd?: Prisma.DecimalFieldUpdateOperationsInput | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
592
|
+
estimatedCostCacheWriteUsd?: Prisma.DecimalFieldUpdateOperationsInput | runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
593
|
+
unpricedInput?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
594
|
+
unpricedOutput?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
595
|
+
unpricedCacheRead?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
596
|
+
unpricedCacheWrite?: Prisma.BigIntFieldUpdateOperationsInput | bigint | number;
|
|
597
|
+
};
|
|
598
|
+
export type UsageDayFleetIdDayMachineShipIdShipIdModelHarnessLoginCompoundUniqueInput = {
|
|
599
|
+
fleetId: string;
|
|
600
|
+
day: Date | string;
|
|
601
|
+
machineShipId: string;
|
|
602
|
+
shipId: string;
|
|
603
|
+
model: string;
|
|
604
|
+
harness: string;
|
|
605
|
+
login: string;
|
|
606
|
+
};
|
|
607
|
+
export type UsageDayCountOrderByAggregateInput = {
|
|
608
|
+
id?: Prisma.SortOrder;
|
|
609
|
+
fleetId?: Prisma.SortOrder;
|
|
610
|
+
day?: Prisma.SortOrder;
|
|
611
|
+
machineShipId?: Prisma.SortOrder;
|
|
612
|
+
shipId?: Prisma.SortOrder;
|
|
613
|
+
model?: Prisma.SortOrder;
|
|
614
|
+
harness?: Prisma.SortOrder;
|
|
615
|
+
login?: Prisma.SortOrder;
|
|
616
|
+
input?: Prisma.SortOrder;
|
|
617
|
+
output?: Prisma.SortOrder;
|
|
618
|
+
cacheRead?: Prisma.SortOrder;
|
|
619
|
+
cacheWrite?: Prisma.SortOrder;
|
|
620
|
+
estimatedCostInputUsd?: Prisma.SortOrder;
|
|
621
|
+
estimatedCostOutputUsd?: Prisma.SortOrder;
|
|
622
|
+
estimatedCostCacheReadUsd?: Prisma.SortOrder;
|
|
623
|
+
estimatedCostCacheWriteUsd?: Prisma.SortOrder;
|
|
624
|
+
unpricedInput?: Prisma.SortOrder;
|
|
625
|
+
unpricedOutput?: Prisma.SortOrder;
|
|
626
|
+
unpricedCacheRead?: Prisma.SortOrder;
|
|
627
|
+
unpricedCacheWrite?: Prisma.SortOrder;
|
|
628
|
+
};
|
|
629
|
+
export type UsageDayAvgOrderByAggregateInput = {
|
|
630
|
+
id?: Prisma.SortOrder;
|
|
631
|
+
input?: Prisma.SortOrder;
|
|
632
|
+
output?: Prisma.SortOrder;
|
|
633
|
+
cacheRead?: Prisma.SortOrder;
|
|
634
|
+
cacheWrite?: Prisma.SortOrder;
|
|
635
|
+
estimatedCostInputUsd?: Prisma.SortOrder;
|
|
636
|
+
estimatedCostOutputUsd?: Prisma.SortOrder;
|
|
637
|
+
estimatedCostCacheReadUsd?: Prisma.SortOrder;
|
|
638
|
+
estimatedCostCacheWriteUsd?: Prisma.SortOrder;
|
|
639
|
+
unpricedInput?: Prisma.SortOrder;
|
|
640
|
+
unpricedOutput?: Prisma.SortOrder;
|
|
641
|
+
unpricedCacheRead?: Prisma.SortOrder;
|
|
642
|
+
unpricedCacheWrite?: Prisma.SortOrder;
|
|
643
|
+
};
|
|
644
|
+
export type UsageDayMaxOrderByAggregateInput = {
|
|
645
|
+
id?: Prisma.SortOrder;
|
|
646
|
+
fleetId?: Prisma.SortOrder;
|
|
647
|
+
day?: Prisma.SortOrder;
|
|
648
|
+
machineShipId?: Prisma.SortOrder;
|
|
649
|
+
shipId?: Prisma.SortOrder;
|
|
650
|
+
model?: Prisma.SortOrder;
|
|
651
|
+
harness?: Prisma.SortOrder;
|
|
652
|
+
login?: Prisma.SortOrder;
|
|
653
|
+
input?: Prisma.SortOrder;
|
|
654
|
+
output?: Prisma.SortOrder;
|
|
655
|
+
cacheRead?: Prisma.SortOrder;
|
|
656
|
+
cacheWrite?: Prisma.SortOrder;
|
|
657
|
+
estimatedCostInputUsd?: Prisma.SortOrder;
|
|
658
|
+
estimatedCostOutputUsd?: Prisma.SortOrder;
|
|
659
|
+
estimatedCostCacheReadUsd?: Prisma.SortOrder;
|
|
660
|
+
estimatedCostCacheWriteUsd?: Prisma.SortOrder;
|
|
661
|
+
unpricedInput?: Prisma.SortOrder;
|
|
662
|
+
unpricedOutput?: Prisma.SortOrder;
|
|
663
|
+
unpricedCacheRead?: Prisma.SortOrder;
|
|
664
|
+
unpricedCacheWrite?: Prisma.SortOrder;
|
|
665
|
+
};
|
|
666
|
+
export type UsageDayMinOrderByAggregateInput = {
|
|
667
|
+
id?: Prisma.SortOrder;
|
|
668
|
+
fleetId?: Prisma.SortOrder;
|
|
669
|
+
day?: Prisma.SortOrder;
|
|
670
|
+
machineShipId?: Prisma.SortOrder;
|
|
671
|
+
shipId?: Prisma.SortOrder;
|
|
672
|
+
model?: Prisma.SortOrder;
|
|
673
|
+
harness?: Prisma.SortOrder;
|
|
674
|
+
login?: Prisma.SortOrder;
|
|
675
|
+
input?: Prisma.SortOrder;
|
|
676
|
+
output?: Prisma.SortOrder;
|
|
677
|
+
cacheRead?: Prisma.SortOrder;
|
|
678
|
+
cacheWrite?: Prisma.SortOrder;
|
|
679
|
+
estimatedCostInputUsd?: Prisma.SortOrder;
|
|
680
|
+
estimatedCostOutputUsd?: Prisma.SortOrder;
|
|
681
|
+
estimatedCostCacheReadUsd?: Prisma.SortOrder;
|
|
682
|
+
estimatedCostCacheWriteUsd?: Prisma.SortOrder;
|
|
683
|
+
unpricedInput?: Prisma.SortOrder;
|
|
684
|
+
unpricedOutput?: Prisma.SortOrder;
|
|
685
|
+
unpricedCacheRead?: Prisma.SortOrder;
|
|
686
|
+
unpricedCacheWrite?: Prisma.SortOrder;
|
|
687
|
+
};
|
|
688
|
+
export type UsageDaySumOrderByAggregateInput = {
|
|
689
|
+
id?: Prisma.SortOrder;
|
|
690
|
+
input?: Prisma.SortOrder;
|
|
691
|
+
output?: Prisma.SortOrder;
|
|
692
|
+
cacheRead?: Prisma.SortOrder;
|
|
693
|
+
cacheWrite?: Prisma.SortOrder;
|
|
694
|
+
estimatedCostInputUsd?: Prisma.SortOrder;
|
|
695
|
+
estimatedCostOutputUsd?: Prisma.SortOrder;
|
|
696
|
+
estimatedCostCacheReadUsd?: Prisma.SortOrder;
|
|
697
|
+
estimatedCostCacheWriteUsd?: Prisma.SortOrder;
|
|
698
|
+
unpricedInput?: Prisma.SortOrder;
|
|
699
|
+
unpricedOutput?: Prisma.SortOrder;
|
|
700
|
+
unpricedCacheRead?: Prisma.SortOrder;
|
|
701
|
+
unpricedCacheWrite?: Prisma.SortOrder;
|
|
702
|
+
};
|
|
703
|
+
export type DecimalFieldUpdateOperationsInput = {
|
|
704
|
+
set?: runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
705
|
+
increment?: runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
706
|
+
decrement?: runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
707
|
+
multiply?: runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
708
|
+
divide?: runtime.Decimal | runtime.DecimalJsLike | number | string;
|
|
709
|
+
};
|
|
710
|
+
export type UsageDaySelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
|
|
711
|
+
id?: boolean;
|
|
712
|
+
fleetId?: boolean;
|
|
713
|
+
day?: boolean;
|
|
714
|
+
machineShipId?: boolean;
|
|
715
|
+
shipId?: boolean;
|
|
716
|
+
model?: boolean;
|
|
717
|
+
harness?: boolean;
|
|
718
|
+
login?: boolean;
|
|
719
|
+
input?: boolean;
|
|
720
|
+
output?: boolean;
|
|
721
|
+
cacheRead?: boolean;
|
|
722
|
+
cacheWrite?: boolean;
|
|
723
|
+
estimatedCostInputUsd?: boolean;
|
|
724
|
+
estimatedCostOutputUsd?: boolean;
|
|
725
|
+
estimatedCostCacheReadUsd?: boolean;
|
|
726
|
+
estimatedCostCacheWriteUsd?: boolean;
|
|
727
|
+
unpricedInput?: boolean;
|
|
728
|
+
unpricedOutput?: boolean;
|
|
729
|
+
unpricedCacheRead?: boolean;
|
|
730
|
+
unpricedCacheWrite?: boolean;
|
|
731
|
+
}, ExtArgs["result"]["usageDay"]>;
|
|
732
|
+
export type UsageDaySelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
|
|
733
|
+
id?: boolean;
|
|
734
|
+
fleetId?: boolean;
|
|
735
|
+
day?: boolean;
|
|
736
|
+
machineShipId?: boolean;
|
|
737
|
+
shipId?: boolean;
|
|
738
|
+
model?: boolean;
|
|
739
|
+
harness?: boolean;
|
|
740
|
+
login?: boolean;
|
|
741
|
+
input?: boolean;
|
|
742
|
+
output?: boolean;
|
|
743
|
+
cacheRead?: boolean;
|
|
744
|
+
cacheWrite?: boolean;
|
|
745
|
+
estimatedCostInputUsd?: boolean;
|
|
746
|
+
estimatedCostOutputUsd?: boolean;
|
|
747
|
+
estimatedCostCacheReadUsd?: boolean;
|
|
748
|
+
estimatedCostCacheWriteUsd?: boolean;
|
|
749
|
+
unpricedInput?: boolean;
|
|
750
|
+
unpricedOutput?: boolean;
|
|
751
|
+
unpricedCacheRead?: boolean;
|
|
752
|
+
unpricedCacheWrite?: boolean;
|
|
753
|
+
}, ExtArgs["result"]["usageDay"]>;
|
|
754
|
+
export type UsageDaySelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
|
|
755
|
+
id?: boolean;
|
|
756
|
+
fleetId?: boolean;
|
|
757
|
+
day?: boolean;
|
|
758
|
+
machineShipId?: boolean;
|
|
759
|
+
shipId?: boolean;
|
|
760
|
+
model?: boolean;
|
|
761
|
+
harness?: boolean;
|
|
762
|
+
login?: boolean;
|
|
763
|
+
input?: boolean;
|
|
764
|
+
output?: boolean;
|
|
765
|
+
cacheRead?: boolean;
|
|
766
|
+
cacheWrite?: boolean;
|
|
767
|
+
estimatedCostInputUsd?: boolean;
|
|
768
|
+
estimatedCostOutputUsd?: boolean;
|
|
769
|
+
estimatedCostCacheReadUsd?: boolean;
|
|
770
|
+
estimatedCostCacheWriteUsd?: boolean;
|
|
771
|
+
unpricedInput?: boolean;
|
|
772
|
+
unpricedOutput?: boolean;
|
|
773
|
+
unpricedCacheRead?: boolean;
|
|
774
|
+
unpricedCacheWrite?: boolean;
|
|
775
|
+
}, ExtArgs["result"]["usageDay"]>;
|
|
776
|
+
export type UsageDaySelectScalar = {
|
|
777
|
+
id?: boolean;
|
|
778
|
+
fleetId?: boolean;
|
|
779
|
+
day?: boolean;
|
|
780
|
+
machineShipId?: boolean;
|
|
781
|
+
shipId?: boolean;
|
|
782
|
+
model?: boolean;
|
|
783
|
+
harness?: boolean;
|
|
784
|
+
login?: boolean;
|
|
785
|
+
input?: boolean;
|
|
786
|
+
output?: boolean;
|
|
787
|
+
cacheRead?: boolean;
|
|
788
|
+
cacheWrite?: boolean;
|
|
789
|
+
estimatedCostInputUsd?: boolean;
|
|
790
|
+
estimatedCostOutputUsd?: boolean;
|
|
791
|
+
estimatedCostCacheReadUsd?: boolean;
|
|
792
|
+
estimatedCostCacheWriteUsd?: boolean;
|
|
793
|
+
unpricedInput?: boolean;
|
|
794
|
+
unpricedOutput?: boolean;
|
|
795
|
+
unpricedCacheRead?: boolean;
|
|
796
|
+
unpricedCacheWrite?: boolean;
|
|
797
|
+
};
|
|
798
|
+
export type UsageDayOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "fleetId" | "day" | "machineShipId" | "shipId" | "model" | "harness" | "login" | "input" | "output" | "cacheRead" | "cacheWrite" | "estimatedCostInputUsd" | "estimatedCostOutputUsd" | "estimatedCostCacheReadUsd" | "estimatedCostCacheWriteUsd" | "unpricedInput" | "unpricedOutput" | "unpricedCacheRead" | "unpricedCacheWrite", ExtArgs["result"]["usageDay"]>;
|
|
799
|
+
export type $UsageDayPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
800
|
+
name: "UsageDay";
|
|
801
|
+
objects: {};
|
|
802
|
+
scalars: runtime.Types.Extensions.GetPayloadResult<{
|
|
803
|
+
id: bigint;
|
|
804
|
+
fleetId: string;
|
|
805
|
+
day: Date;
|
|
806
|
+
machineShipId: string;
|
|
807
|
+
shipId: string;
|
|
808
|
+
model: string;
|
|
809
|
+
harness: string;
|
|
810
|
+
login: string | null;
|
|
811
|
+
input: bigint;
|
|
812
|
+
output: bigint;
|
|
813
|
+
cacheRead: bigint;
|
|
814
|
+
cacheWrite: bigint;
|
|
815
|
+
/**
|
|
816
|
+
* The estimated cost of each kind of tokens, of the priced hours only.
|
|
817
|
+
*/
|
|
818
|
+
estimatedCostInputUsd: runtime.Decimal;
|
|
819
|
+
estimatedCostOutputUsd: runtime.Decimal;
|
|
820
|
+
estimatedCostCacheReadUsd: runtime.Decimal;
|
|
821
|
+
estimatedCostCacheWriteUsd: runtime.Decimal;
|
|
822
|
+
/**
|
|
823
|
+
* The tokens of each kind of the hours whose model the trierarch does not price.
|
|
824
|
+
*/
|
|
825
|
+
unpricedInput: bigint;
|
|
826
|
+
unpricedOutput: bigint;
|
|
827
|
+
unpricedCacheRead: bigint;
|
|
828
|
+
unpricedCacheWrite: bigint;
|
|
829
|
+
}, ExtArgs["result"]["usageDay"]>;
|
|
830
|
+
composites: {};
|
|
831
|
+
};
|
|
832
|
+
export type UsageDayGetPayload<S extends boolean | null | undefined | UsageDayDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$UsageDayPayload, S>;
|
|
833
|
+
export type UsageDayCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = Omit<UsageDayFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
834
|
+
select?: UsageDayCountAggregateInputType | true;
|
|
835
|
+
};
|
|
836
|
+
export interface UsageDayDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
837
|
+
[K: symbol]: {
|
|
838
|
+
types: Prisma.TypeMap<ExtArgs>['model']['UsageDay'];
|
|
839
|
+
meta: {
|
|
840
|
+
name: 'UsageDay';
|
|
841
|
+
};
|
|
842
|
+
};
|
|
843
|
+
/**
|
|
844
|
+
* Find zero or one UsageDay that matches the filter.
|
|
845
|
+
* @param {UsageDayFindUniqueArgs} args - Arguments to find a UsageDay
|
|
846
|
+
* @example
|
|
847
|
+
* // Get one UsageDay
|
|
848
|
+
* const usageDay = await prisma.usageDay.findUnique({
|
|
849
|
+
* where: {
|
|
850
|
+
* // ... provide filter here
|
|
851
|
+
* }
|
|
852
|
+
* })
|
|
853
|
+
*/
|
|
854
|
+
findUnique<T extends UsageDayFindUniqueArgs>(args: Prisma.SelectSubset<T, UsageDayFindUniqueArgs<ExtArgs>>): Prisma.Prisma__UsageDayClient<runtime.Types.Result.GetResult<Prisma.$UsageDayPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>;
|
|
855
|
+
/**
|
|
856
|
+
* Find one UsageDay that matches the filter or throw an error with `error.code='P2025'`
|
|
857
|
+
* if no matches were found.
|
|
858
|
+
* @param {UsageDayFindUniqueOrThrowArgs} args - Arguments to find a UsageDay
|
|
859
|
+
* @example
|
|
860
|
+
* // Get one UsageDay
|
|
861
|
+
* const usageDay = await prisma.usageDay.findUniqueOrThrow({
|
|
862
|
+
* where: {
|
|
863
|
+
* // ... provide filter here
|
|
864
|
+
* }
|
|
865
|
+
* })
|
|
866
|
+
*/
|
|
867
|
+
findUniqueOrThrow<T extends UsageDayFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, UsageDayFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__UsageDayClient<runtime.Types.Result.GetResult<Prisma.$UsageDayPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
|
|
868
|
+
/**
|
|
869
|
+
* Find the first UsageDay that matches the filter.
|
|
870
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
871
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
872
|
+
* @param {UsageDayFindFirstArgs} args - Arguments to find a UsageDay
|
|
873
|
+
* @example
|
|
874
|
+
* // Get one UsageDay
|
|
875
|
+
* const usageDay = await prisma.usageDay.findFirst({
|
|
876
|
+
* where: {
|
|
877
|
+
* // ... provide filter here
|
|
878
|
+
* }
|
|
879
|
+
* })
|
|
880
|
+
*/
|
|
881
|
+
findFirst<T extends UsageDayFindFirstArgs>(args?: Prisma.SelectSubset<T, UsageDayFindFirstArgs<ExtArgs>>): Prisma.Prisma__UsageDayClient<runtime.Types.Result.GetResult<Prisma.$UsageDayPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>;
|
|
882
|
+
/**
|
|
883
|
+
* Find the first UsageDay that matches the filter or
|
|
884
|
+
* throw `PrismaKnownClientError` with `P2025` code if no matches were found.
|
|
885
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
886
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
887
|
+
* @param {UsageDayFindFirstOrThrowArgs} args - Arguments to find a UsageDay
|
|
888
|
+
* @example
|
|
889
|
+
* // Get one UsageDay
|
|
890
|
+
* const usageDay = await prisma.usageDay.findFirstOrThrow({
|
|
891
|
+
* where: {
|
|
892
|
+
* // ... provide filter here
|
|
893
|
+
* }
|
|
894
|
+
* })
|
|
895
|
+
*/
|
|
896
|
+
findFirstOrThrow<T extends UsageDayFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, UsageDayFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__UsageDayClient<runtime.Types.Result.GetResult<Prisma.$UsageDayPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
|
|
897
|
+
/**
|
|
898
|
+
* Find zero or more UsageDays that matches the filter.
|
|
899
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
900
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
901
|
+
* @param {UsageDayFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
902
|
+
* @example
|
|
903
|
+
* // Get all UsageDays
|
|
904
|
+
* const usageDays = await prisma.usageDay.findMany()
|
|
905
|
+
*
|
|
906
|
+
* // Get first 10 UsageDays
|
|
907
|
+
* const usageDays = await prisma.usageDay.findMany({ take: 10 })
|
|
908
|
+
*
|
|
909
|
+
* // Only select the `id`
|
|
910
|
+
* const usageDayWithIdOnly = await prisma.usageDay.findMany({ select: { id: true } })
|
|
911
|
+
*
|
|
912
|
+
*/
|
|
913
|
+
findMany<T extends UsageDayFindManyArgs>(args?: Prisma.SelectSubset<T, UsageDayFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$UsageDayPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>;
|
|
914
|
+
/**
|
|
915
|
+
* Create a UsageDay.
|
|
916
|
+
* @param {UsageDayCreateArgs} args - Arguments to create a UsageDay.
|
|
917
|
+
* @example
|
|
918
|
+
* // Create one UsageDay
|
|
919
|
+
* const UsageDay = await prisma.usageDay.create({
|
|
920
|
+
* data: {
|
|
921
|
+
* // ... data to create a UsageDay
|
|
922
|
+
* }
|
|
923
|
+
* })
|
|
924
|
+
*
|
|
925
|
+
*/
|
|
926
|
+
create<T extends UsageDayCreateArgs>(args: Prisma.SelectSubset<T, UsageDayCreateArgs<ExtArgs>>): Prisma.Prisma__UsageDayClient<runtime.Types.Result.GetResult<Prisma.$UsageDayPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
|
|
927
|
+
/**
|
|
928
|
+
* Create many UsageDays.
|
|
929
|
+
* @param {UsageDayCreateManyArgs} args - Arguments to create many UsageDays.
|
|
930
|
+
* @example
|
|
931
|
+
* // Create many UsageDays
|
|
932
|
+
* const usageDay = await prisma.usageDay.createMany({
|
|
933
|
+
* data: [
|
|
934
|
+
* // ... provide data here
|
|
935
|
+
* ]
|
|
936
|
+
* })
|
|
937
|
+
*
|
|
938
|
+
*/
|
|
939
|
+
createMany<T extends UsageDayCreateManyArgs>(args?: Prisma.SelectSubset<T, UsageDayCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>;
|
|
940
|
+
/**
|
|
941
|
+
* Create many UsageDays and returns the data saved in the database.
|
|
942
|
+
* @param {UsageDayCreateManyAndReturnArgs} args - Arguments to create many UsageDays.
|
|
943
|
+
* @example
|
|
944
|
+
* // Create many UsageDays
|
|
945
|
+
* const usageDay = await prisma.usageDay.createManyAndReturn({
|
|
946
|
+
* data: [
|
|
947
|
+
* // ... provide data here
|
|
948
|
+
* ]
|
|
949
|
+
* })
|
|
950
|
+
*
|
|
951
|
+
* // Create many UsageDays and only return the `id`
|
|
952
|
+
* const usageDayWithIdOnly = await prisma.usageDay.createManyAndReturn({
|
|
953
|
+
* select: { id: true },
|
|
954
|
+
* data: [
|
|
955
|
+
* // ... provide data here
|
|
956
|
+
* ]
|
|
957
|
+
* })
|
|
958
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
959
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
960
|
+
*
|
|
961
|
+
*/
|
|
962
|
+
createManyAndReturn<T extends UsageDayCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, UsageDayCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$UsageDayPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>;
|
|
963
|
+
/**
|
|
964
|
+
* Delete a UsageDay.
|
|
965
|
+
* @param {UsageDayDeleteArgs} args - Arguments to delete one UsageDay.
|
|
966
|
+
* @example
|
|
967
|
+
* // Delete one UsageDay
|
|
968
|
+
* const UsageDay = await prisma.usageDay.delete({
|
|
969
|
+
* where: {
|
|
970
|
+
* // ... filter to delete one UsageDay
|
|
971
|
+
* }
|
|
972
|
+
* })
|
|
973
|
+
*
|
|
974
|
+
*/
|
|
975
|
+
delete<T extends UsageDayDeleteArgs>(args: Prisma.SelectSubset<T, UsageDayDeleteArgs<ExtArgs>>): Prisma.Prisma__UsageDayClient<runtime.Types.Result.GetResult<Prisma.$UsageDayPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
|
|
976
|
+
/**
|
|
977
|
+
* Update one UsageDay.
|
|
978
|
+
* @param {UsageDayUpdateArgs} args - Arguments to update one UsageDay.
|
|
979
|
+
* @example
|
|
980
|
+
* // Update one UsageDay
|
|
981
|
+
* const usageDay = await prisma.usageDay.update({
|
|
982
|
+
* where: {
|
|
983
|
+
* // ... provide filter here
|
|
984
|
+
* },
|
|
985
|
+
* data: {
|
|
986
|
+
* // ... provide data here
|
|
987
|
+
* }
|
|
988
|
+
* })
|
|
989
|
+
*
|
|
990
|
+
*/
|
|
991
|
+
update<T extends UsageDayUpdateArgs>(args: Prisma.SelectSubset<T, UsageDayUpdateArgs<ExtArgs>>): Prisma.Prisma__UsageDayClient<runtime.Types.Result.GetResult<Prisma.$UsageDayPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
|
|
992
|
+
/**
|
|
993
|
+
* Delete zero or more UsageDays.
|
|
994
|
+
* @param {UsageDayDeleteManyArgs} args - Arguments to filter UsageDays to delete.
|
|
995
|
+
* @example
|
|
996
|
+
* // Delete a few UsageDays
|
|
997
|
+
* const { count } = await prisma.usageDay.deleteMany({
|
|
998
|
+
* where: {
|
|
999
|
+
* // ... provide filter here
|
|
1000
|
+
* }
|
|
1001
|
+
* })
|
|
1002
|
+
*
|
|
1003
|
+
*/
|
|
1004
|
+
deleteMany<T extends UsageDayDeleteManyArgs>(args?: Prisma.SelectSubset<T, UsageDayDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>;
|
|
1005
|
+
/**
|
|
1006
|
+
* Update zero or more UsageDays.
|
|
1007
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
1008
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
1009
|
+
* @param {UsageDayUpdateManyArgs} args - Arguments to update one or more rows.
|
|
1010
|
+
* @example
|
|
1011
|
+
* // Update many UsageDays
|
|
1012
|
+
* const usageDay = await prisma.usageDay.updateMany({
|
|
1013
|
+
* where: {
|
|
1014
|
+
* // ... provide filter here
|
|
1015
|
+
* },
|
|
1016
|
+
* data: {
|
|
1017
|
+
* // ... provide data here
|
|
1018
|
+
* }
|
|
1019
|
+
* })
|
|
1020
|
+
*
|
|
1021
|
+
*/
|
|
1022
|
+
updateMany<T extends UsageDayUpdateManyArgs>(args: Prisma.SelectSubset<T, UsageDayUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>;
|
|
1023
|
+
/**
|
|
1024
|
+
* Update zero or more UsageDays and returns the data updated in the database.
|
|
1025
|
+
* @param {UsageDayUpdateManyAndReturnArgs} args - Arguments to update many UsageDays.
|
|
1026
|
+
* @example
|
|
1027
|
+
* // Update many UsageDays
|
|
1028
|
+
* const usageDay = await prisma.usageDay.updateManyAndReturn({
|
|
1029
|
+
* where: {
|
|
1030
|
+
* // ... provide filter here
|
|
1031
|
+
* },
|
|
1032
|
+
* data: [
|
|
1033
|
+
* // ... provide data here
|
|
1034
|
+
* ]
|
|
1035
|
+
* })
|
|
1036
|
+
*
|
|
1037
|
+
* // Update zero or more UsageDays and only return the `id`
|
|
1038
|
+
* const usageDayWithIdOnly = await prisma.usageDay.updateManyAndReturn({
|
|
1039
|
+
* select: { id: true },
|
|
1040
|
+
* where: {
|
|
1041
|
+
* // ... provide filter here
|
|
1042
|
+
* },
|
|
1043
|
+
* data: [
|
|
1044
|
+
* // ... provide data here
|
|
1045
|
+
* ]
|
|
1046
|
+
* })
|
|
1047
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
1048
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
1049
|
+
*
|
|
1050
|
+
*/
|
|
1051
|
+
updateManyAndReturn<T extends UsageDayUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, UsageDayUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$UsageDayPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>;
|
|
1052
|
+
/**
|
|
1053
|
+
* Create or update one UsageDay.
|
|
1054
|
+
* @param {UsageDayUpsertArgs} args - Arguments to update or create a UsageDay.
|
|
1055
|
+
* @example
|
|
1056
|
+
* // Update or create a UsageDay
|
|
1057
|
+
* const usageDay = await prisma.usageDay.upsert({
|
|
1058
|
+
* create: {
|
|
1059
|
+
* // ... data to create a UsageDay
|
|
1060
|
+
* },
|
|
1061
|
+
* update: {
|
|
1062
|
+
* // ... in case it already exists, update
|
|
1063
|
+
* },
|
|
1064
|
+
* where: {
|
|
1065
|
+
* // ... the filter for the UsageDay we want to update
|
|
1066
|
+
* }
|
|
1067
|
+
* })
|
|
1068
|
+
*/
|
|
1069
|
+
upsert<T extends UsageDayUpsertArgs>(args: Prisma.SelectSubset<T, UsageDayUpsertArgs<ExtArgs>>): Prisma.Prisma__UsageDayClient<runtime.Types.Result.GetResult<Prisma.$UsageDayPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
|
|
1070
|
+
/**
|
|
1071
|
+
* Count the number of UsageDays.
|
|
1072
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
1073
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
1074
|
+
* @param {UsageDayCountArgs} args - Arguments to filter UsageDays to count.
|
|
1075
|
+
* @example
|
|
1076
|
+
* // Count the number of UsageDays
|
|
1077
|
+
* const count = await prisma.usageDay.count({
|
|
1078
|
+
* where: {
|
|
1079
|
+
* // ... the filter for the UsageDays we want to count
|
|
1080
|
+
* }
|
|
1081
|
+
* })
|
|
1082
|
+
**/
|
|
1083
|
+
count<T extends UsageDayCountArgs>(args?: Prisma.Subset<T, UsageDayCountArgs>): Prisma.PrismaPromise<T extends runtime.Types.Utils.Record<'select', any> ? T['select'] extends true ? number : Prisma.GetScalarType<T['select'], UsageDayCountAggregateOutputType> : number>;
|
|
1084
|
+
/**
|
|
1085
|
+
* Allows you to perform aggregations operations on a UsageDay.
|
|
1086
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
1087
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
1088
|
+
* @param {UsageDayAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
|
|
1089
|
+
* @example
|
|
1090
|
+
* // Ordered by age ascending
|
|
1091
|
+
* // Where email contains prisma.io
|
|
1092
|
+
* // Limited to the 10 users
|
|
1093
|
+
* const aggregations = await prisma.user.aggregate({
|
|
1094
|
+
* _avg: {
|
|
1095
|
+
* age: true,
|
|
1096
|
+
* },
|
|
1097
|
+
* where: {
|
|
1098
|
+
* email: {
|
|
1099
|
+
* contains: "prisma.io",
|
|
1100
|
+
* },
|
|
1101
|
+
* },
|
|
1102
|
+
* orderBy: {
|
|
1103
|
+
* age: "asc",
|
|
1104
|
+
* },
|
|
1105
|
+
* take: 10,
|
|
1106
|
+
* })
|
|
1107
|
+
**/
|
|
1108
|
+
aggregate<T extends UsageDayAggregateArgs>(args: Prisma.Subset<T, UsageDayAggregateArgs>): Prisma.PrismaPromise<GetUsageDayAggregateType<T>>;
|
|
1109
|
+
/**
|
|
1110
|
+
* Group by UsageDay.
|
|
1111
|
+
* Note, that providing `undefined` is treated as the value not being there.
|
|
1112
|
+
* Read more here: https://pris.ly/d/null-undefined
|
|
1113
|
+
* @param {UsageDayGroupByArgs} args - Group by arguments.
|
|
1114
|
+
* @example
|
|
1115
|
+
* // Group by city, order by createdAt, get count
|
|
1116
|
+
* const result = await prisma.user.groupBy({
|
|
1117
|
+
* by: ['city', 'createdAt'],
|
|
1118
|
+
* orderBy: {
|
|
1119
|
+
* createdAt: true
|
|
1120
|
+
* },
|
|
1121
|
+
* _count: {
|
|
1122
|
+
* _all: true
|
|
1123
|
+
* },
|
|
1124
|
+
* })
|
|
1125
|
+
*
|
|
1126
|
+
**/
|
|
1127
|
+
groupBy<T extends UsageDayGroupByArgs, HasSelectOrTake extends Prisma.Or<Prisma.Extends<'skip', Prisma.Keys<T>>, Prisma.Extends<'take', Prisma.Keys<T>>>, OrderByArg extends Prisma.True extends HasSelectOrTake ? {
|
|
1128
|
+
orderBy: UsageDayGroupByArgs['orderBy'];
|
|
1129
|
+
} : {
|
|
1130
|
+
orderBy?: UsageDayGroupByArgs['orderBy'];
|
|
1131
|
+
}, 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 ? {
|
|
1132
|
+
[P in HavingFields]: P extends ByFields ? never : P extends string ? `Error: Field "${P}" used in "having" needs to be provided in "by".` : [
|
|
1133
|
+
Error,
|
|
1134
|
+
'Field ',
|
|
1135
|
+
P,
|
|
1136
|
+
` in "having" needs to be provided in "by"`
|
|
1137
|
+
];
|
|
1138
|
+
}[HavingFields] : 'take' extends Prisma.Keys<T> ? 'orderBy' extends Prisma.Keys<T> ? ByValid extends Prisma.True ? {} : {
|
|
1139
|
+
[P in OrderFields]: P extends ByFields ? never : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`;
|
|
1140
|
+
}[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 ? {} : {
|
|
1141
|
+
[P in OrderFields]: P extends ByFields ? never : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`;
|
|
1142
|
+
}[OrderFields] : 'Error: If you provide "skip", you also need to provide "orderBy"' : ByValid extends Prisma.True ? {} : {
|
|
1143
|
+
[P in OrderFields]: P extends ByFields ? never : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`;
|
|
1144
|
+
}[OrderFields]>(args: Prisma.SubsetIntersection<T, UsageDayGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetUsageDayGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>;
|
|
1145
|
+
/**
|
|
1146
|
+
* Fields of the UsageDay model
|
|
1147
|
+
*/
|
|
1148
|
+
readonly fields: UsageDayFieldRefs;
|
|
1149
|
+
}
|
|
1150
|
+
/**
|
|
1151
|
+
* The delegate class that acts as a "Promise-like" for UsageDay.
|
|
1152
|
+
* Why is this prefixed with `Prisma__`?
|
|
1153
|
+
* Because we want to prevent naming conflicts as mentioned in
|
|
1154
|
+
* https://github.com/prisma/prisma-client-js/issues/707
|
|
1155
|
+
*/
|
|
1156
|
+
export interface Prisma__UsageDayClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
1157
|
+
readonly [Symbol.toStringTag]: "PrismaPromise";
|
|
1158
|
+
/**
|
|
1159
|
+
* Attaches callbacks for the resolution and/or rejection of the Promise.
|
|
1160
|
+
* @param onfulfilled The callback to execute when the Promise is resolved.
|
|
1161
|
+
* @param onrejected The callback to execute when the Promise is rejected.
|
|
1162
|
+
* @returns A Promise for the completion of which ever callback is executed.
|
|
1163
|
+
*/
|
|
1164
|
+
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>;
|
|
1165
|
+
/**
|
|
1166
|
+
* Attaches a callback for only the rejection of the Promise.
|
|
1167
|
+
* @param onrejected The callback to execute when the Promise is rejected.
|
|
1168
|
+
* @returns A Promise for the completion of the callback.
|
|
1169
|
+
*/
|
|
1170
|
+
catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>;
|
|
1171
|
+
/**
|
|
1172
|
+
* Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
|
|
1173
|
+
* resolved value cannot be modified from the callback.
|
|
1174
|
+
* @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
|
|
1175
|
+
* @returns A Promise for the completion of the callback.
|
|
1176
|
+
*/
|
|
1177
|
+
finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>;
|
|
1178
|
+
}
|
|
1179
|
+
/**
|
|
1180
|
+
* Fields of the UsageDay model
|
|
1181
|
+
*/
|
|
1182
|
+
export interface UsageDayFieldRefs {
|
|
1183
|
+
readonly id: Prisma.FieldRef<"UsageDay", 'BigInt'>;
|
|
1184
|
+
readonly fleetId: Prisma.FieldRef<"UsageDay", 'String'>;
|
|
1185
|
+
readonly day: Prisma.FieldRef<"UsageDay", 'DateTime'>;
|
|
1186
|
+
readonly machineShipId: Prisma.FieldRef<"UsageDay", 'String'>;
|
|
1187
|
+
readonly shipId: Prisma.FieldRef<"UsageDay", 'String'>;
|
|
1188
|
+
readonly model: Prisma.FieldRef<"UsageDay", 'String'>;
|
|
1189
|
+
readonly harness: Prisma.FieldRef<"UsageDay", 'String'>;
|
|
1190
|
+
readonly login: Prisma.FieldRef<"UsageDay", 'String'>;
|
|
1191
|
+
readonly input: Prisma.FieldRef<"UsageDay", 'BigInt'>;
|
|
1192
|
+
readonly output: Prisma.FieldRef<"UsageDay", 'BigInt'>;
|
|
1193
|
+
readonly cacheRead: Prisma.FieldRef<"UsageDay", 'BigInt'>;
|
|
1194
|
+
readonly cacheWrite: Prisma.FieldRef<"UsageDay", 'BigInt'>;
|
|
1195
|
+
readonly estimatedCostInputUsd: Prisma.FieldRef<"UsageDay", 'Decimal'>;
|
|
1196
|
+
readonly estimatedCostOutputUsd: Prisma.FieldRef<"UsageDay", 'Decimal'>;
|
|
1197
|
+
readonly estimatedCostCacheReadUsd: Prisma.FieldRef<"UsageDay", 'Decimal'>;
|
|
1198
|
+
readonly estimatedCostCacheWriteUsd: Prisma.FieldRef<"UsageDay", 'Decimal'>;
|
|
1199
|
+
readonly unpricedInput: Prisma.FieldRef<"UsageDay", 'BigInt'>;
|
|
1200
|
+
readonly unpricedOutput: Prisma.FieldRef<"UsageDay", 'BigInt'>;
|
|
1201
|
+
readonly unpricedCacheRead: Prisma.FieldRef<"UsageDay", 'BigInt'>;
|
|
1202
|
+
readonly unpricedCacheWrite: Prisma.FieldRef<"UsageDay", 'BigInt'>;
|
|
1203
|
+
}
|
|
1204
|
+
/**
|
|
1205
|
+
* UsageDay findUnique
|
|
1206
|
+
*/
|
|
1207
|
+
export type UsageDayFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1208
|
+
/**
|
|
1209
|
+
* Select specific fields to fetch from the UsageDay
|
|
1210
|
+
*/
|
|
1211
|
+
select?: Prisma.UsageDaySelect<ExtArgs> | null;
|
|
1212
|
+
/**
|
|
1213
|
+
* Omit specific fields from the UsageDay
|
|
1214
|
+
*/
|
|
1215
|
+
omit?: Prisma.UsageDayOmit<ExtArgs> | null;
|
|
1216
|
+
/**
|
|
1217
|
+
* Filter, which UsageDay to fetch.
|
|
1218
|
+
*/
|
|
1219
|
+
where: Prisma.UsageDayWhereUniqueInput;
|
|
1220
|
+
};
|
|
1221
|
+
/**
|
|
1222
|
+
* UsageDay findUniqueOrThrow
|
|
1223
|
+
*/
|
|
1224
|
+
export type UsageDayFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1225
|
+
/**
|
|
1226
|
+
* Select specific fields to fetch from the UsageDay
|
|
1227
|
+
*/
|
|
1228
|
+
select?: Prisma.UsageDaySelect<ExtArgs> | null;
|
|
1229
|
+
/**
|
|
1230
|
+
* Omit specific fields from the UsageDay
|
|
1231
|
+
*/
|
|
1232
|
+
omit?: Prisma.UsageDayOmit<ExtArgs> | null;
|
|
1233
|
+
/**
|
|
1234
|
+
* Filter, which UsageDay to fetch.
|
|
1235
|
+
*/
|
|
1236
|
+
where: Prisma.UsageDayWhereUniqueInput;
|
|
1237
|
+
};
|
|
1238
|
+
/**
|
|
1239
|
+
* UsageDay findFirst
|
|
1240
|
+
*/
|
|
1241
|
+
export type UsageDayFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1242
|
+
/**
|
|
1243
|
+
* Select specific fields to fetch from the UsageDay
|
|
1244
|
+
*/
|
|
1245
|
+
select?: Prisma.UsageDaySelect<ExtArgs> | null;
|
|
1246
|
+
/**
|
|
1247
|
+
* Omit specific fields from the UsageDay
|
|
1248
|
+
*/
|
|
1249
|
+
omit?: Prisma.UsageDayOmit<ExtArgs> | null;
|
|
1250
|
+
/**
|
|
1251
|
+
* Filter, which UsageDay to fetch.
|
|
1252
|
+
*/
|
|
1253
|
+
where?: Prisma.UsageDayWhereInput;
|
|
1254
|
+
/**
|
|
1255
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
1256
|
+
*
|
|
1257
|
+
* Determine the order of UsageDays to fetch.
|
|
1258
|
+
*/
|
|
1259
|
+
orderBy?: Prisma.UsageDayOrderByWithRelationInput | Prisma.UsageDayOrderByWithRelationInput[];
|
|
1260
|
+
/**
|
|
1261
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
1262
|
+
*
|
|
1263
|
+
* Sets the position for searching for UsageDays.
|
|
1264
|
+
*/
|
|
1265
|
+
cursor?: Prisma.UsageDayWhereUniqueInput;
|
|
1266
|
+
/**
|
|
1267
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
1268
|
+
*
|
|
1269
|
+
* Take `±n` UsageDays from the position of the cursor.
|
|
1270
|
+
*/
|
|
1271
|
+
take?: number;
|
|
1272
|
+
/**
|
|
1273
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
1274
|
+
*
|
|
1275
|
+
* Skip the first `n` UsageDays.
|
|
1276
|
+
*/
|
|
1277
|
+
skip?: number;
|
|
1278
|
+
/**
|
|
1279
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
1280
|
+
*
|
|
1281
|
+
* Filter by unique combinations of UsageDays.
|
|
1282
|
+
*/
|
|
1283
|
+
distinct?: Prisma.UsageDayScalarFieldEnum | Prisma.UsageDayScalarFieldEnum[];
|
|
1284
|
+
};
|
|
1285
|
+
/**
|
|
1286
|
+
* UsageDay findFirstOrThrow
|
|
1287
|
+
*/
|
|
1288
|
+
export type UsageDayFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1289
|
+
/**
|
|
1290
|
+
* Select specific fields to fetch from the UsageDay
|
|
1291
|
+
*/
|
|
1292
|
+
select?: Prisma.UsageDaySelect<ExtArgs> | null;
|
|
1293
|
+
/**
|
|
1294
|
+
* Omit specific fields from the UsageDay
|
|
1295
|
+
*/
|
|
1296
|
+
omit?: Prisma.UsageDayOmit<ExtArgs> | null;
|
|
1297
|
+
/**
|
|
1298
|
+
* Filter, which UsageDay to fetch.
|
|
1299
|
+
*/
|
|
1300
|
+
where?: Prisma.UsageDayWhereInput;
|
|
1301
|
+
/**
|
|
1302
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
1303
|
+
*
|
|
1304
|
+
* Determine the order of UsageDays to fetch.
|
|
1305
|
+
*/
|
|
1306
|
+
orderBy?: Prisma.UsageDayOrderByWithRelationInput | Prisma.UsageDayOrderByWithRelationInput[];
|
|
1307
|
+
/**
|
|
1308
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
1309
|
+
*
|
|
1310
|
+
* Sets the position for searching for UsageDays.
|
|
1311
|
+
*/
|
|
1312
|
+
cursor?: Prisma.UsageDayWhereUniqueInput;
|
|
1313
|
+
/**
|
|
1314
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
1315
|
+
*
|
|
1316
|
+
* Take `±n` UsageDays from the position of the cursor.
|
|
1317
|
+
*/
|
|
1318
|
+
take?: number;
|
|
1319
|
+
/**
|
|
1320
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
1321
|
+
*
|
|
1322
|
+
* Skip the first `n` UsageDays.
|
|
1323
|
+
*/
|
|
1324
|
+
skip?: number;
|
|
1325
|
+
/**
|
|
1326
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
1327
|
+
*
|
|
1328
|
+
* Filter by unique combinations of UsageDays.
|
|
1329
|
+
*/
|
|
1330
|
+
distinct?: Prisma.UsageDayScalarFieldEnum | Prisma.UsageDayScalarFieldEnum[];
|
|
1331
|
+
};
|
|
1332
|
+
/**
|
|
1333
|
+
* UsageDay findMany
|
|
1334
|
+
*/
|
|
1335
|
+
export type UsageDayFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1336
|
+
/**
|
|
1337
|
+
* Select specific fields to fetch from the UsageDay
|
|
1338
|
+
*/
|
|
1339
|
+
select?: Prisma.UsageDaySelect<ExtArgs> | null;
|
|
1340
|
+
/**
|
|
1341
|
+
* Omit specific fields from the UsageDay
|
|
1342
|
+
*/
|
|
1343
|
+
omit?: Prisma.UsageDayOmit<ExtArgs> | null;
|
|
1344
|
+
/**
|
|
1345
|
+
* Filter, which UsageDays to fetch.
|
|
1346
|
+
*/
|
|
1347
|
+
where?: Prisma.UsageDayWhereInput;
|
|
1348
|
+
/**
|
|
1349
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
1350
|
+
*
|
|
1351
|
+
* Determine the order of UsageDays to fetch.
|
|
1352
|
+
*/
|
|
1353
|
+
orderBy?: Prisma.UsageDayOrderByWithRelationInput | Prisma.UsageDayOrderByWithRelationInput[];
|
|
1354
|
+
/**
|
|
1355
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
1356
|
+
*
|
|
1357
|
+
* Sets the position for listing UsageDays.
|
|
1358
|
+
*/
|
|
1359
|
+
cursor?: Prisma.UsageDayWhereUniqueInput;
|
|
1360
|
+
/**
|
|
1361
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
1362
|
+
*
|
|
1363
|
+
* Take `±n` UsageDays from the position of the cursor.
|
|
1364
|
+
*/
|
|
1365
|
+
take?: number;
|
|
1366
|
+
/**
|
|
1367
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
1368
|
+
*
|
|
1369
|
+
* Skip the first `n` UsageDays.
|
|
1370
|
+
*/
|
|
1371
|
+
skip?: number;
|
|
1372
|
+
/**
|
|
1373
|
+
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
1374
|
+
*
|
|
1375
|
+
* Filter by unique combinations of UsageDays.
|
|
1376
|
+
*/
|
|
1377
|
+
distinct?: Prisma.UsageDayScalarFieldEnum | Prisma.UsageDayScalarFieldEnum[];
|
|
1378
|
+
};
|
|
1379
|
+
/**
|
|
1380
|
+
* UsageDay create
|
|
1381
|
+
*/
|
|
1382
|
+
export type UsageDayCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1383
|
+
/**
|
|
1384
|
+
* Select specific fields to fetch from the UsageDay
|
|
1385
|
+
*/
|
|
1386
|
+
select?: Prisma.UsageDaySelect<ExtArgs> | null;
|
|
1387
|
+
/**
|
|
1388
|
+
* Omit specific fields from the UsageDay
|
|
1389
|
+
*/
|
|
1390
|
+
omit?: Prisma.UsageDayOmit<ExtArgs> | null;
|
|
1391
|
+
/**
|
|
1392
|
+
* The data needed to create a UsageDay.
|
|
1393
|
+
*/
|
|
1394
|
+
data: Prisma.XOR<Prisma.UsageDayCreateInput, Prisma.UsageDayUncheckedCreateInput>;
|
|
1395
|
+
};
|
|
1396
|
+
/**
|
|
1397
|
+
* UsageDay createMany
|
|
1398
|
+
*/
|
|
1399
|
+
export type UsageDayCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1400
|
+
/**
|
|
1401
|
+
* The data used to create many UsageDays.
|
|
1402
|
+
*/
|
|
1403
|
+
data: Prisma.UsageDayCreateManyInput | Prisma.UsageDayCreateManyInput[];
|
|
1404
|
+
skipDuplicates?: boolean;
|
|
1405
|
+
};
|
|
1406
|
+
/**
|
|
1407
|
+
* UsageDay createManyAndReturn
|
|
1408
|
+
*/
|
|
1409
|
+
export type UsageDayCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1410
|
+
/**
|
|
1411
|
+
* Select specific fields to fetch from the UsageDay
|
|
1412
|
+
*/
|
|
1413
|
+
select?: Prisma.UsageDaySelectCreateManyAndReturn<ExtArgs> | null;
|
|
1414
|
+
/**
|
|
1415
|
+
* Omit specific fields from the UsageDay
|
|
1416
|
+
*/
|
|
1417
|
+
omit?: Prisma.UsageDayOmit<ExtArgs> | null;
|
|
1418
|
+
/**
|
|
1419
|
+
* The data used to create many UsageDays.
|
|
1420
|
+
*/
|
|
1421
|
+
data: Prisma.UsageDayCreateManyInput | Prisma.UsageDayCreateManyInput[];
|
|
1422
|
+
skipDuplicates?: boolean;
|
|
1423
|
+
};
|
|
1424
|
+
/**
|
|
1425
|
+
* UsageDay update
|
|
1426
|
+
*/
|
|
1427
|
+
export type UsageDayUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1428
|
+
/**
|
|
1429
|
+
* Select specific fields to fetch from the UsageDay
|
|
1430
|
+
*/
|
|
1431
|
+
select?: Prisma.UsageDaySelect<ExtArgs> | null;
|
|
1432
|
+
/**
|
|
1433
|
+
* Omit specific fields from the UsageDay
|
|
1434
|
+
*/
|
|
1435
|
+
omit?: Prisma.UsageDayOmit<ExtArgs> | null;
|
|
1436
|
+
/**
|
|
1437
|
+
* The data needed to update a UsageDay.
|
|
1438
|
+
*/
|
|
1439
|
+
data: Prisma.XOR<Prisma.UsageDayUpdateInput, Prisma.UsageDayUncheckedUpdateInput>;
|
|
1440
|
+
/**
|
|
1441
|
+
* Choose, which UsageDay to update.
|
|
1442
|
+
*/
|
|
1443
|
+
where: Prisma.UsageDayWhereUniqueInput;
|
|
1444
|
+
};
|
|
1445
|
+
/**
|
|
1446
|
+
* UsageDay updateMany
|
|
1447
|
+
*/
|
|
1448
|
+
export type UsageDayUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1449
|
+
/**
|
|
1450
|
+
* The data used to update UsageDays.
|
|
1451
|
+
*/
|
|
1452
|
+
data: Prisma.XOR<Prisma.UsageDayUpdateManyMutationInput, Prisma.UsageDayUncheckedUpdateManyInput>;
|
|
1453
|
+
/**
|
|
1454
|
+
* Filter which UsageDays to update
|
|
1455
|
+
*/
|
|
1456
|
+
where?: Prisma.UsageDayWhereInput;
|
|
1457
|
+
/**
|
|
1458
|
+
* Limit how many UsageDays to update.
|
|
1459
|
+
*/
|
|
1460
|
+
limit?: number;
|
|
1461
|
+
};
|
|
1462
|
+
/**
|
|
1463
|
+
* UsageDay updateManyAndReturn
|
|
1464
|
+
*/
|
|
1465
|
+
export type UsageDayUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1466
|
+
/**
|
|
1467
|
+
* Select specific fields to fetch from the UsageDay
|
|
1468
|
+
*/
|
|
1469
|
+
select?: Prisma.UsageDaySelectUpdateManyAndReturn<ExtArgs> | null;
|
|
1470
|
+
/**
|
|
1471
|
+
* Omit specific fields from the UsageDay
|
|
1472
|
+
*/
|
|
1473
|
+
omit?: Prisma.UsageDayOmit<ExtArgs> | null;
|
|
1474
|
+
/**
|
|
1475
|
+
* The data used to update UsageDays.
|
|
1476
|
+
*/
|
|
1477
|
+
data: Prisma.XOR<Prisma.UsageDayUpdateManyMutationInput, Prisma.UsageDayUncheckedUpdateManyInput>;
|
|
1478
|
+
/**
|
|
1479
|
+
* Filter which UsageDays to update
|
|
1480
|
+
*/
|
|
1481
|
+
where?: Prisma.UsageDayWhereInput;
|
|
1482
|
+
/**
|
|
1483
|
+
* Limit how many UsageDays to update.
|
|
1484
|
+
*/
|
|
1485
|
+
limit?: number;
|
|
1486
|
+
};
|
|
1487
|
+
/**
|
|
1488
|
+
* UsageDay upsert
|
|
1489
|
+
*/
|
|
1490
|
+
export type UsageDayUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1491
|
+
/**
|
|
1492
|
+
* Select specific fields to fetch from the UsageDay
|
|
1493
|
+
*/
|
|
1494
|
+
select?: Prisma.UsageDaySelect<ExtArgs> | null;
|
|
1495
|
+
/**
|
|
1496
|
+
* Omit specific fields from the UsageDay
|
|
1497
|
+
*/
|
|
1498
|
+
omit?: Prisma.UsageDayOmit<ExtArgs> | null;
|
|
1499
|
+
/**
|
|
1500
|
+
* The filter to search for the UsageDay to update in case it exists.
|
|
1501
|
+
*/
|
|
1502
|
+
where: Prisma.UsageDayWhereUniqueInput;
|
|
1503
|
+
/**
|
|
1504
|
+
* In case the UsageDay found by the `where` argument doesn't exist, create a new UsageDay with this data.
|
|
1505
|
+
*/
|
|
1506
|
+
create: Prisma.XOR<Prisma.UsageDayCreateInput, Prisma.UsageDayUncheckedCreateInput>;
|
|
1507
|
+
/**
|
|
1508
|
+
* In case the UsageDay was found with the provided `where` argument, update it with this data.
|
|
1509
|
+
*/
|
|
1510
|
+
update: Prisma.XOR<Prisma.UsageDayUpdateInput, Prisma.UsageDayUncheckedUpdateInput>;
|
|
1511
|
+
};
|
|
1512
|
+
/**
|
|
1513
|
+
* UsageDay delete
|
|
1514
|
+
*/
|
|
1515
|
+
export type UsageDayDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1516
|
+
/**
|
|
1517
|
+
* Select specific fields to fetch from the UsageDay
|
|
1518
|
+
*/
|
|
1519
|
+
select?: Prisma.UsageDaySelect<ExtArgs> | null;
|
|
1520
|
+
/**
|
|
1521
|
+
* Omit specific fields from the UsageDay
|
|
1522
|
+
*/
|
|
1523
|
+
omit?: Prisma.UsageDayOmit<ExtArgs> | null;
|
|
1524
|
+
/**
|
|
1525
|
+
* Filter which UsageDay to delete.
|
|
1526
|
+
*/
|
|
1527
|
+
where: Prisma.UsageDayWhereUniqueInput;
|
|
1528
|
+
};
|
|
1529
|
+
/**
|
|
1530
|
+
* UsageDay deleteMany
|
|
1531
|
+
*/
|
|
1532
|
+
export type UsageDayDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1533
|
+
/**
|
|
1534
|
+
* Filter which UsageDays to delete
|
|
1535
|
+
*/
|
|
1536
|
+
where?: Prisma.UsageDayWhereInput;
|
|
1537
|
+
/**
|
|
1538
|
+
* Limit how many UsageDays to delete.
|
|
1539
|
+
*/
|
|
1540
|
+
limit?: number;
|
|
1541
|
+
};
|
|
1542
|
+
/**
|
|
1543
|
+
* UsageDay without action
|
|
1544
|
+
*/
|
|
1545
|
+
export type UsageDayDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
|
|
1546
|
+
/**
|
|
1547
|
+
* Select specific fields to fetch from the UsageDay
|
|
1548
|
+
*/
|
|
1549
|
+
select?: Prisma.UsageDaySelect<ExtArgs> | null;
|
|
1550
|
+
/**
|
|
1551
|
+
* Omit specific fields from the UsageDay
|
|
1552
|
+
*/
|
|
1553
|
+
omit?: Prisma.UsageDayOmit<ExtArgs> | null;
|
|
1554
|
+
};
|