@bubblelab/shared-schemas 0.1.44 → 0.1.46
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.
|
@@ -1,4 +1,124 @@
|
|
|
1
1
|
import { z } from '@hono/zod-openapi';
|
|
2
|
+
/**
|
|
3
|
+
* Token usage breakdown by model
|
|
4
|
+
*/
|
|
5
|
+
export declare const tokenUsageSchema: z.ZodObject<{
|
|
6
|
+
modelName: z.ZodOptional<z.ZodString>;
|
|
7
|
+
inputTokens: z.ZodNumber;
|
|
8
|
+
outputTokens: z.ZodNumber;
|
|
9
|
+
totalTokens: z.ZodNumber;
|
|
10
|
+
}, "strip", z.ZodTypeAny, {
|
|
11
|
+
inputTokens: number;
|
|
12
|
+
outputTokens: number;
|
|
13
|
+
totalTokens: number;
|
|
14
|
+
modelName?: string | undefined;
|
|
15
|
+
}, {
|
|
16
|
+
inputTokens: number;
|
|
17
|
+
outputTokens: number;
|
|
18
|
+
totalTokens: number;
|
|
19
|
+
modelName?: string | undefined;
|
|
20
|
+
}>;
|
|
21
|
+
export type TokenUsage = z.infer<typeof tokenUsageSchema>;
|
|
22
|
+
/**
|
|
23
|
+
* Reusable usage schema for both personal and organization usage
|
|
24
|
+
*/
|
|
25
|
+
export declare const usageSchema: z.ZodObject<{
|
|
26
|
+
executionCount: z.ZodNumber;
|
|
27
|
+
tokenUsage: z.ZodArray<z.ZodObject<{
|
|
28
|
+
modelName: z.ZodOptional<z.ZodString>;
|
|
29
|
+
inputTokens: z.ZodNumber;
|
|
30
|
+
outputTokens: z.ZodNumber;
|
|
31
|
+
totalTokens: z.ZodNumber;
|
|
32
|
+
}, "strip", z.ZodTypeAny, {
|
|
33
|
+
inputTokens: number;
|
|
34
|
+
outputTokens: number;
|
|
35
|
+
totalTokens: number;
|
|
36
|
+
modelName?: string | undefined;
|
|
37
|
+
}, {
|
|
38
|
+
inputTokens: number;
|
|
39
|
+
outputTokens: number;
|
|
40
|
+
totalTokens: number;
|
|
41
|
+
modelName?: string | undefined;
|
|
42
|
+
}>, "many">;
|
|
43
|
+
serviceUsage: z.ZodArray<z.ZodObject<{
|
|
44
|
+
service: z.ZodNativeEnum<typeof import("./types").CredentialType>;
|
|
45
|
+
subService: z.ZodOptional<z.ZodString>;
|
|
46
|
+
unit: z.ZodString;
|
|
47
|
+
usage: z.ZodNumber;
|
|
48
|
+
unitCost: z.ZodNumber;
|
|
49
|
+
totalCost: z.ZodNumber;
|
|
50
|
+
}, "strip", z.ZodTypeAny, {
|
|
51
|
+
service: import("./types").CredentialType;
|
|
52
|
+
unit: string;
|
|
53
|
+
usage: number;
|
|
54
|
+
unitCost: number;
|
|
55
|
+
totalCost: number;
|
|
56
|
+
subService?: string | undefined;
|
|
57
|
+
}, {
|
|
58
|
+
service: import("./types").CredentialType;
|
|
59
|
+
unit: string;
|
|
60
|
+
usage: number;
|
|
61
|
+
unitCost: number;
|
|
62
|
+
totalCost: number;
|
|
63
|
+
subService?: string | undefined;
|
|
64
|
+
}>, "many">;
|
|
65
|
+
}, "strip", z.ZodTypeAny, {
|
|
66
|
+
serviceUsage: {
|
|
67
|
+
service: import("./types").CredentialType;
|
|
68
|
+
unit: string;
|
|
69
|
+
usage: number;
|
|
70
|
+
unitCost: number;
|
|
71
|
+
totalCost: number;
|
|
72
|
+
subService?: string | undefined;
|
|
73
|
+
}[];
|
|
74
|
+
executionCount: number;
|
|
75
|
+
tokenUsage: {
|
|
76
|
+
inputTokens: number;
|
|
77
|
+
outputTokens: number;
|
|
78
|
+
totalTokens: number;
|
|
79
|
+
modelName?: string | undefined;
|
|
80
|
+
}[];
|
|
81
|
+
}, {
|
|
82
|
+
serviceUsage: {
|
|
83
|
+
service: import("./types").CredentialType;
|
|
84
|
+
unit: string;
|
|
85
|
+
usage: number;
|
|
86
|
+
unitCost: number;
|
|
87
|
+
totalCost: number;
|
|
88
|
+
subService?: string | undefined;
|
|
89
|
+
}[];
|
|
90
|
+
executionCount: number;
|
|
91
|
+
tokenUsage: {
|
|
92
|
+
inputTokens: number;
|
|
93
|
+
outputTokens: number;
|
|
94
|
+
totalTokens: number;
|
|
95
|
+
modelName?: string | undefined;
|
|
96
|
+
}[];
|
|
97
|
+
}>;
|
|
98
|
+
export type Usage = z.infer<typeof usageSchema>;
|
|
99
|
+
/**
|
|
100
|
+
* Organization billing context - shows which org the billing belongs to
|
|
101
|
+
*/
|
|
102
|
+
export declare const billingOrganizationSchema: z.ZodObject<{
|
|
103
|
+
id: z.ZodNumber;
|
|
104
|
+
name: z.ZodString;
|
|
105
|
+
slug: z.ZodString;
|
|
106
|
+
role: z.ZodEnum<["owner", "admin", "member"]>;
|
|
107
|
+
memberCount: z.ZodNumber;
|
|
108
|
+
}, "strip", z.ZodTypeAny, {
|
|
109
|
+
role: "owner" | "admin" | "member";
|
|
110
|
+
name: string;
|
|
111
|
+
id: number;
|
|
112
|
+
slug: string;
|
|
113
|
+
memberCount: number;
|
|
114
|
+
}, {
|
|
115
|
+
role: "owner" | "admin" | "member";
|
|
116
|
+
name: string;
|
|
117
|
+
id: number;
|
|
118
|
+
slug: string;
|
|
119
|
+
memberCount: number;
|
|
120
|
+
}>;
|
|
121
|
+
export type BillingOrganization = z.infer<typeof billingOrganizationSchema>;
|
|
2
122
|
export declare const hackathonOfferSchema: z.ZodObject<{
|
|
3
123
|
isActive: z.ZodBoolean;
|
|
4
124
|
expiresAt: z.ZodString;
|
|
@@ -54,6 +174,25 @@ export declare const subscriptionStatusResponseSchema: z.ZodObject<{
|
|
|
54
174
|
plan: z.ZodString;
|
|
55
175
|
planDisplayName: z.ZodString;
|
|
56
176
|
features: z.ZodArray<z.ZodString, "many">;
|
|
177
|
+
organization: z.ZodOptional<z.ZodObject<{
|
|
178
|
+
id: z.ZodNumber;
|
|
179
|
+
name: z.ZodString;
|
|
180
|
+
slug: z.ZodString;
|
|
181
|
+
role: z.ZodEnum<["owner", "admin", "member"]>;
|
|
182
|
+
memberCount: z.ZodNumber;
|
|
183
|
+
}, "strip", z.ZodTypeAny, {
|
|
184
|
+
role: "owner" | "admin" | "member";
|
|
185
|
+
name: string;
|
|
186
|
+
id: number;
|
|
187
|
+
slug: string;
|
|
188
|
+
memberCount: number;
|
|
189
|
+
}, {
|
|
190
|
+
role: "owner" | "admin" | "member";
|
|
191
|
+
name: string;
|
|
192
|
+
id: number;
|
|
193
|
+
slug: string;
|
|
194
|
+
memberCount: number;
|
|
195
|
+
}>>;
|
|
57
196
|
usage: z.ZodObject<{
|
|
58
197
|
executionCount: z.ZodNumber;
|
|
59
198
|
executionLimit: z.ZodNumber;
|
|
@@ -62,20 +201,20 @@ export declare const subscriptionStatusResponseSchema: z.ZodObject<{
|
|
|
62
201
|
estimatedMonthlyCost: z.ZodNumber;
|
|
63
202
|
resetDate: z.ZodString;
|
|
64
203
|
tokenUsage: z.ZodArray<z.ZodObject<{
|
|
65
|
-
modelName: z.ZodString
|
|
204
|
+
modelName: z.ZodOptional<z.ZodString>;
|
|
66
205
|
inputTokens: z.ZodNumber;
|
|
67
206
|
outputTokens: z.ZodNumber;
|
|
68
207
|
totalTokens: z.ZodNumber;
|
|
69
208
|
}, "strip", z.ZodTypeAny, {
|
|
70
|
-
modelName: string;
|
|
71
209
|
inputTokens: number;
|
|
72
210
|
outputTokens: number;
|
|
73
211
|
totalTokens: number;
|
|
212
|
+
modelName?: string | undefined;
|
|
74
213
|
}, {
|
|
75
|
-
modelName: string;
|
|
76
214
|
inputTokens: number;
|
|
77
215
|
outputTokens: number;
|
|
78
216
|
totalTokens: number;
|
|
217
|
+
modelName?: string | undefined;
|
|
79
218
|
}>, "many">;
|
|
80
219
|
serviceUsage: z.ZodArray<z.ZodObject<{
|
|
81
220
|
service: z.ZodNativeEnum<typeof import("./types").CredentialType>;
|
|
@@ -109,17 +248,17 @@ export declare const subscriptionStatusResponseSchema: z.ZodObject<{
|
|
|
109
248
|
subService?: string | undefined;
|
|
110
249
|
}[];
|
|
111
250
|
executionCount: number;
|
|
112
|
-
executionLimit: number;
|
|
113
|
-
creditLimit: number;
|
|
114
|
-
activeFlowLimit: number;
|
|
115
|
-
estimatedMonthlyCost: number;
|
|
116
|
-
resetDate: string;
|
|
117
251
|
tokenUsage: {
|
|
118
|
-
modelName: string;
|
|
119
252
|
inputTokens: number;
|
|
120
253
|
outputTokens: number;
|
|
121
254
|
totalTokens: number;
|
|
255
|
+
modelName?: string | undefined;
|
|
122
256
|
}[];
|
|
257
|
+
executionLimit: number;
|
|
258
|
+
creditLimit: number;
|
|
259
|
+
activeFlowLimit: number;
|
|
260
|
+
estimatedMonthlyCost: number;
|
|
261
|
+
resetDate: string;
|
|
123
262
|
}, {
|
|
124
263
|
serviceUsage: {
|
|
125
264
|
service: import("./types").CredentialType;
|
|
@@ -130,18 +269,91 @@ export declare const subscriptionStatusResponseSchema: z.ZodObject<{
|
|
|
130
269
|
subService?: string | undefined;
|
|
131
270
|
}[];
|
|
132
271
|
executionCount: number;
|
|
272
|
+
tokenUsage: {
|
|
273
|
+
inputTokens: number;
|
|
274
|
+
outputTokens: number;
|
|
275
|
+
totalTokens: number;
|
|
276
|
+
modelName?: string | undefined;
|
|
277
|
+
}[];
|
|
133
278
|
executionLimit: number;
|
|
134
279
|
creditLimit: number;
|
|
135
280
|
activeFlowLimit: number;
|
|
136
281
|
estimatedMonthlyCost: number;
|
|
137
282
|
resetDate: string;
|
|
283
|
+
}>;
|
|
284
|
+
personalUsage: z.ZodOptional<z.ZodObject<{
|
|
285
|
+
executionCount: z.ZodNumber;
|
|
286
|
+
tokenUsage: z.ZodArray<z.ZodObject<{
|
|
287
|
+
modelName: z.ZodOptional<z.ZodString>;
|
|
288
|
+
inputTokens: z.ZodNumber;
|
|
289
|
+
outputTokens: z.ZodNumber;
|
|
290
|
+
totalTokens: z.ZodNumber;
|
|
291
|
+
}, "strip", z.ZodTypeAny, {
|
|
292
|
+
inputTokens: number;
|
|
293
|
+
outputTokens: number;
|
|
294
|
+
totalTokens: number;
|
|
295
|
+
modelName?: string | undefined;
|
|
296
|
+
}, {
|
|
297
|
+
inputTokens: number;
|
|
298
|
+
outputTokens: number;
|
|
299
|
+
totalTokens: number;
|
|
300
|
+
modelName?: string | undefined;
|
|
301
|
+
}>, "many">;
|
|
302
|
+
serviceUsage: z.ZodArray<z.ZodObject<{
|
|
303
|
+
service: z.ZodNativeEnum<typeof import("./types").CredentialType>;
|
|
304
|
+
subService: z.ZodOptional<z.ZodString>;
|
|
305
|
+
unit: z.ZodString;
|
|
306
|
+
usage: z.ZodNumber;
|
|
307
|
+
unitCost: z.ZodNumber;
|
|
308
|
+
totalCost: z.ZodNumber;
|
|
309
|
+
}, "strip", z.ZodTypeAny, {
|
|
310
|
+
service: import("./types").CredentialType;
|
|
311
|
+
unit: string;
|
|
312
|
+
usage: number;
|
|
313
|
+
unitCost: number;
|
|
314
|
+
totalCost: number;
|
|
315
|
+
subService?: string | undefined;
|
|
316
|
+
}, {
|
|
317
|
+
service: import("./types").CredentialType;
|
|
318
|
+
unit: string;
|
|
319
|
+
usage: number;
|
|
320
|
+
unitCost: number;
|
|
321
|
+
totalCost: number;
|
|
322
|
+
subService?: string | undefined;
|
|
323
|
+
}>, "many">;
|
|
324
|
+
}, "strip", z.ZodTypeAny, {
|
|
325
|
+
serviceUsage: {
|
|
326
|
+
service: import("./types").CredentialType;
|
|
327
|
+
unit: string;
|
|
328
|
+
usage: number;
|
|
329
|
+
unitCost: number;
|
|
330
|
+
totalCost: number;
|
|
331
|
+
subService?: string | undefined;
|
|
332
|
+
}[];
|
|
333
|
+
executionCount: number;
|
|
138
334
|
tokenUsage: {
|
|
139
|
-
modelName: string;
|
|
140
335
|
inputTokens: number;
|
|
141
336
|
outputTokens: number;
|
|
142
337
|
totalTokens: number;
|
|
338
|
+
modelName?: string | undefined;
|
|
143
339
|
}[];
|
|
144
|
-
}
|
|
340
|
+
}, {
|
|
341
|
+
serviceUsage: {
|
|
342
|
+
service: import("./types").CredentialType;
|
|
343
|
+
unit: string;
|
|
344
|
+
usage: number;
|
|
345
|
+
unitCost: number;
|
|
346
|
+
totalCost: number;
|
|
347
|
+
subService?: string | undefined;
|
|
348
|
+
}[];
|
|
349
|
+
executionCount: number;
|
|
350
|
+
tokenUsage: {
|
|
351
|
+
inputTokens: number;
|
|
352
|
+
outputTokens: number;
|
|
353
|
+
totalTokens: number;
|
|
354
|
+
modelName?: string | undefined;
|
|
355
|
+
}[];
|
|
356
|
+
}>>;
|
|
145
357
|
isActive: z.ZodBoolean;
|
|
146
358
|
hackathonOffer: z.ZodOptional<z.ZodObject<{
|
|
147
359
|
isActive: z.ZodBoolean;
|
|
@@ -180,23 +392,47 @@ export declare const subscriptionStatusResponseSchema: z.ZodObject<{
|
|
|
180
392
|
subService?: string | undefined;
|
|
181
393
|
}[];
|
|
182
394
|
executionCount: number;
|
|
183
|
-
executionLimit: number;
|
|
184
|
-
creditLimit: number;
|
|
185
|
-
activeFlowLimit: number;
|
|
186
|
-
estimatedMonthlyCost: number;
|
|
187
|
-
resetDate: string;
|
|
188
395
|
tokenUsage: {
|
|
189
|
-
modelName: string;
|
|
190
396
|
inputTokens: number;
|
|
191
397
|
outputTokens: number;
|
|
192
398
|
totalTokens: number;
|
|
399
|
+
modelName?: string | undefined;
|
|
193
400
|
}[];
|
|
401
|
+
executionLimit: number;
|
|
402
|
+
creditLimit: number;
|
|
403
|
+
activeFlowLimit: number;
|
|
404
|
+
estimatedMonthlyCost: number;
|
|
405
|
+
resetDate: string;
|
|
194
406
|
};
|
|
195
407
|
userId: string;
|
|
196
408
|
isActive: boolean;
|
|
197
409
|
plan: string;
|
|
198
410
|
planDisplayName: string;
|
|
199
411
|
features: string[];
|
|
412
|
+
organization?: {
|
|
413
|
+
role: "owner" | "admin" | "member";
|
|
414
|
+
name: string;
|
|
415
|
+
id: number;
|
|
416
|
+
slug: string;
|
|
417
|
+
memberCount: number;
|
|
418
|
+
} | undefined;
|
|
419
|
+
personalUsage?: {
|
|
420
|
+
serviceUsage: {
|
|
421
|
+
service: import("./types").CredentialType;
|
|
422
|
+
unit: string;
|
|
423
|
+
usage: number;
|
|
424
|
+
unitCost: number;
|
|
425
|
+
totalCost: number;
|
|
426
|
+
subService?: string | undefined;
|
|
427
|
+
}[];
|
|
428
|
+
executionCount: number;
|
|
429
|
+
tokenUsage: {
|
|
430
|
+
inputTokens: number;
|
|
431
|
+
outputTokens: number;
|
|
432
|
+
totalTokens: number;
|
|
433
|
+
modelName?: string | undefined;
|
|
434
|
+
}[];
|
|
435
|
+
} | undefined;
|
|
200
436
|
hackathonOffer?: {
|
|
201
437
|
isActive: boolean;
|
|
202
438
|
expiresAt: string;
|
|
@@ -218,23 +454,47 @@ export declare const subscriptionStatusResponseSchema: z.ZodObject<{
|
|
|
218
454
|
subService?: string | undefined;
|
|
219
455
|
}[];
|
|
220
456
|
executionCount: number;
|
|
221
|
-
executionLimit: number;
|
|
222
|
-
creditLimit: number;
|
|
223
|
-
activeFlowLimit: number;
|
|
224
|
-
estimatedMonthlyCost: number;
|
|
225
|
-
resetDate: string;
|
|
226
457
|
tokenUsage: {
|
|
227
|
-
modelName: string;
|
|
228
458
|
inputTokens: number;
|
|
229
459
|
outputTokens: number;
|
|
230
460
|
totalTokens: number;
|
|
461
|
+
modelName?: string | undefined;
|
|
231
462
|
}[];
|
|
463
|
+
executionLimit: number;
|
|
464
|
+
creditLimit: number;
|
|
465
|
+
activeFlowLimit: number;
|
|
466
|
+
estimatedMonthlyCost: number;
|
|
467
|
+
resetDate: string;
|
|
232
468
|
};
|
|
233
469
|
userId: string;
|
|
234
470
|
isActive: boolean;
|
|
235
471
|
plan: string;
|
|
236
472
|
planDisplayName: string;
|
|
237
473
|
features: string[];
|
|
474
|
+
organization?: {
|
|
475
|
+
role: "owner" | "admin" | "member";
|
|
476
|
+
name: string;
|
|
477
|
+
id: number;
|
|
478
|
+
slug: string;
|
|
479
|
+
memberCount: number;
|
|
480
|
+
} | undefined;
|
|
481
|
+
personalUsage?: {
|
|
482
|
+
serviceUsage: {
|
|
483
|
+
service: import("./types").CredentialType;
|
|
484
|
+
unit: string;
|
|
485
|
+
usage: number;
|
|
486
|
+
unitCost: number;
|
|
487
|
+
totalCost: number;
|
|
488
|
+
subService?: string | undefined;
|
|
489
|
+
}[];
|
|
490
|
+
executionCount: number;
|
|
491
|
+
tokenUsage: {
|
|
492
|
+
inputTokens: number;
|
|
493
|
+
outputTokens: number;
|
|
494
|
+
totalTokens: number;
|
|
495
|
+
modelName?: string | undefined;
|
|
496
|
+
}[];
|
|
497
|
+
} | undefined;
|
|
238
498
|
hackathonOffer?: {
|
|
239
499
|
isActive: boolean;
|
|
240
500
|
expiresAt: string;
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"subscription-status-schema.d.ts","sourceRoot":"","sources":["../src/subscription-status-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;
|
|
1
|
+
{"version":3,"file":"subscription-status-schema.d.ts","sourceRoot":"","sources":["../src/subscription-status-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAQtC;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;EAmBL,CAAC;AAEzB,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAaL,CAAC;AAEpB,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEhD;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;EAsBL,CAAC;AAElC,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAO5E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAeL,CAAC;AAE7B,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAGlE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAgBL,CAAC;AAE3B,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAG9D,eAAO,MAAM,yBAAyB;;;;;;EAOL,CAAC;AAElC,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAG5E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;EAeL,CAAC;AAEnC,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyEL,CAAC;AAEzC,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC"}
|