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