@bikefinder/staff-sdk 0.8.2 → 0.9.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +7 -0
- package/dist/{chunk-RLPKRCLR.js → chunk-EJ6ZAUPX.js} +438 -371
- package/dist/index.d.ts +5787 -2
- package/dist/index.js +21 -3
- package/dist/schemas.d.ts +5785 -0
- package/dist/schemas.js +19 -1
- package/package.json +1 -1
|
@@ -641,7 +641,7 @@ var observations_schema_default = {
|
|
|
641
641
|
type: "string",
|
|
642
642
|
minLength: 1,
|
|
643
643
|
maxLength: 23,
|
|
644
|
-
pattern: "^(slot:[0-7]|msp430:[0-9a-f]{16})$"
|
|
644
|
+
pattern: "^(slot:[0-7]|ffffffffffffff0[0-7]|(?:msp430:)?(?!0000000000000000|ffffffffffffff)[0-9a-f]{16})$"
|
|
645
645
|
},
|
|
646
646
|
Version: {
|
|
647
647
|
type: "string",
|
|
@@ -888,7 +888,7 @@ var observations_schema_default = {
|
|
|
888
888
|
type: "string",
|
|
889
889
|
minLength: 1,
|
|
890
890
|
maxLength: 23,
|
|
891
|
-
pattern: "^msp430:[0-9a-f]{16}$"
|
|
891
|
+
pattern: "^(?:msp430:)?(?!0000000000000000|ffffffffffffff)[0-9a-f]{16}$"
|
|
892
892
|
},
|
|
893
893
|
{
|
|
894
894
|
type: "null"
|
|
@@ -11863,6 +11863,7 @@ var observations_schema_default = {
|
|
|
11863
11863
|
};
|
|
11864
11864
|
|
|
11865
11865
|
// ../../../nucleus/packages/protocol/observations.ts
|
|
11866
|
+
var batteryModuleId = z14.string().regex(new RegExp(observations_schema_default.$defs.ModuleSubject.pattern));
|
|
11866
11867
|
var key = "bikefinder-observations";
|
|
11867
11868
|
var ajv = addFormats(
|
|
11868
11869
|
new Ajv2020({ strict: false, strictNumbers: true, discriminator: true })
|
|
@@ -14859,7 +14860,7 @@ var commandResponseReceipt = z21.strictObject({
|
|
|
14859
14860
|
value: commandResponseValue
|
|
14860
14861
|
});
|
|
14861
14862
|
var batteryArtifact = z21.strictObject({
|
|
14862
|
-
moduleId:
|
|
14863
|
+
moduleId: batteryModuleId,
|
|
14863
14864
|
version: z21.string().refine((value) => {
|
|
14864
14865
|
if (!/^\d+\.\d+\.\d+(?:\.\d+)?$/.test(value)) return false;
|
|
14865
14866
|
const parts = value.split(".").map(Number);
|
|
@@ -15155,67 +15156,123 @@ var favoriteContract = {
|
|
|
15155
15156
|
remove: oc16.errors(apiErrors).input(favoriteInput).output(z26.void())
|
|
15156
15157
|
};
|
|
15157
15158
|
|
|
15158
|
-
// ../staff-contracts/src/
|
|
15159
|
+
// ../staff-contracts/src/firmware-catalog.ts
|
|
15159
15160
|
import { oc as oc17 } from "@orpc/contract";
|
|
15160
15161
|
import { z as z27 } from "zod";
|
|
15161
|
-
var
|
|
15162
|
+
var firmwareCatalogFamily = z27.enum(["gen2-lte", "gen2-battery"]);
|
|
15163
|
+
var firmwareCatalogCapability = "firmware-catalog-v1";
|
|
15164
|
+
var maximumFirmwareUploadBytes = 1024 * 1024;
|
|
15165
|
+
var catalogFirmwareVersion = z27.string().max(15).regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:\.(0|[1-9]\d*))?$/).refine(
|
|
15166
|
+
(value) => value.split(".").every((part) => Number(part) <= 255),
|
|
15167
|
+
"Use version components from 0 to 255."
|
|
15168
|
+
);
|
|
15169
|
+
var digest = z27.string().regex(/^[a-f0-9]{64}$/);
|
|
15170
|
+
var catalogId = z27.string().regex(/^[A-Za-z0-9_.-]{1,100}$/);
|
|
15171
|
+
var firmwareCatalogUploadInput = z27.strictObject({
|
|
15172
|
+
family: firmwareCatalogFamily,
|
|
15173
|
+
version: catalogFirmwareVersion,
|
|
15174
|
+
notes: z27.string().trim().min(1).max(2e3),
|
|
15175
|
+
sourceRevision: z27.string().regex(/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/).nullable(),
|
|
15176
|
+
buildFingerprint: digest.nullable(),
|
|
15177
|
+
size: z27.int().min(1).max(maximumFirmwareUploadBytes),
|
|
15178
|
+
sha256: digest
|
|
15179
|
+
});
|
|
15180
|
+
var firmwareCatalogPublishInput = firmwareCatalogUploadInput.extend({
|
|
15181
|
+
file: z27.file().min(1).max(maximumFirmwareUploadBytes).mime("application/octet-stream")
|
|
15182
|
+
});
|
|
15183
|
+
var firmwareCatalogRelease = z27.object({
|
|
15184
|
+
id: catalogId,
|
|
15185
|
+
family: firmwareCatalogFamily,
|
|
15186
|
+
version: catalogFirmwareVersion,
|
|
15187
|
+
revision: digest,
|
|
15188
|
+
size: z27.int().positive(),
|
|
15189
|
+
sha256: digest,
|
|
15190
|
+
notes: z27.string(),
|
|
15191
|
+
sourceRevision: z27.string().nullable(),
|
|
15192
|
+
buildFingerprint: z27.string().nullable(),
|
|
15193
|
+
downloadUrl: z27.url({ protocol: /^https$/ }),
|
|
15194
|
+
availableForUpdates: z27.boolean()
|
|
15195
|
+
});
|
|
15196
|
+
var firmwareCatalogInput = z27.strictObject({ id: catalogId });
|
|
15197
|
+
var firmwareCatalogContract = {
|
|
15198
|
+
list: oc17.meta({ operation: "read" }).errors(firmwareErrors).input(
|
|
15199
|
+
z27.strictObject({
|
|
15200
|
+
family: firmwareCatalogFamily,
|
|
15201
|
+
limit: z27.int().min(1).max(100).default(25),
|
|
15202
|
+
after: z27.string().max(1024).nullable().optional()
|
|
15203
|
+
})
|
|
15204
|
+
).output(
|
|
15205
|
+
z27.object({
|
|
15206
|
+
items: z27.array(firmwareCatalogRelease),
|
|
15207
|
+
nextAfter: z27.string().nullable()
|
|
15208
|
+
})
|
|
15209
|
+
),
|
|
15210
|
+
get: oc17.meta({ operation: "read" }).errors(firmwareErrors).input(firmwareCatalogInput).output(firmwareCatalogRelease),
|
|
15211
|
+
publish: oc17.errors(firmwareErrors).input(firmwareCatalogPublishInput).output(firmwareCatalogRelease),
|
|
15212
|
+
enable: oc17.errors(firmwareErrors).input(firmwareCatalogInput.extend({ revision: digest })).output(firmwareCatalogRelease)
|
|
15213
|
+
};
|
|
15214
|
+
|
|
15215
|
+
// ../staff-contracts/src/gcp/maintenance.ts
|
|
15216
|
+
import { oc as oc18 } from "@orpc/contract";
|
|
15217
|
+
import { z as z28 } from "zod";
|
|
15218
|
+
var maintenanceInput = z28.strictObject({
|
|
15162
15219
|
deviceId: documentId,
|
|
15163
15220
|
requestId
|
|
15164
15221
|
});
|
|
15165
15222
|
var denylistInput = maintenanceInput.extend({
|
|
15166
|
-
blacklisted:
|
|
15223
|
+
blacklisted: z28.boolean()
|
|
15167
15224
|
});
|
|
15168
|
-
var maintenanceAccepted =
|
|
15225
|
+
var maintenanceAccepted = z28.object({
|
|
15169
15226
|
deviceId: documentId,
|
|
15170
15227
|
requestId
|
|
15171
15228
|
});
|
|
15172
|
-
var operationExecution =
|
|
15173
|
-
state:
|
|
15174
|
-
attempts:
|
|
15175
|
-
finishedAt:
|
|
15229
|
+
var operationExecution = z28.object({
|
|
15230
|
+
state: z28.string().nullable(),
|
|
15231
|
+
attempts: z28.int().nullable(),
|
|
15232
|
+
finishedAt: z28.iso.datetime().nullable()
|
|
15176
15233
|
});
|
|
15177
|
-
var maintenanceOperation =
|
|
15234
|
+
var maintenanceOperation = z28.object({
|
|
15178
15235
|
...documentFields,
|
|
15179
15236
|
deviceId: documentId,
|
|
15180
|
-
trackerCreatedAt:
|
|
15181
|
-
operation:
|
|
15182
|
-
jobId:
|
|
15183
|
-
requestedBy:
|
|
15184
|
-
acceptedAt:
|
|
15237
|
+
trackerCreatedAt: z28.iso.datetime(),
|
|
15238
|
+
operation: z28.enum(["clean", "denylist"]),
|
|
15239
|
+
jobId: z28.string().regex(/^[a-f0-9]{64}$/).nullable(),
|
|
15240
|
+
requestedBy: z28.string().nullable(),
|
|
15241
|
+
acceptedAt: z28.iso.datetime().nullable(),
|
|
15185
15242
|
execution: operationExecution.nullable()
|
|
15186
15243
|
});
|
|
15187
15244
|
var maintenanceContract = {
|
|
15188
|
-
clean:
|
|
15189
|
-
setDenylist:
|
|
15190
|
-
get:
|
|
15245
|
+
clean: oc18.errors(apiErrors).input(maintenanceInput).output(maintenanceAccepted),
|
|
15246
|
+
setDenylist: oc18.errors(apiErrors).input(denylistInput).output(maintenanceAccepted),
|
|
15247
|
+
get: oc18.meta({ operation: "read" }).errors(apiErrors).input(maintenanceInput).output(maintenanceOperation)
|
|
15191
15248
|
};
|
|
15192
15249
|
|
|
15193
15250
|
// ../staff-contracts/src/gcp/sim.ts
|
|
15194
|
-
import { oc as
|
|
15195
|
-
import { z as
|
|
15196
|
-
var simStatus =
|
|
15197
|
-
iccid:
|
|
15198
|
-
found:
|
|
15199
|
-
status:
|
|
15200
|
-
checkedAt:
|
|
15251
|
+
import { oc as oc19 } from "@orpc/contract";
|
|
15252
|
+
import { z as z29 } from "zod";
|
|
15253
|
+
var simStatus = z29.object({
|
|
15254
|
+
iccid: z29.string().regex(/^[0-9]{18,22}$/),
|
|
15255
|
+
found: z29.boolean(),
|
|
15256
|
+
status: z29.string().nullable(),
|
|
15257
|
+
checkedAt: z29.iso.datetime()
|
|
15201
15258
|
});
|
|
15202
|
-
var simStatusContract =
|
|
15259
|
+
var simStatusContract = oc19.meta({ operation: "read" }).errors(apiErrors).input(trackerInput).output(simStatus);
|
|
15203
15260
|
|
|
15204
15261
|
// ../staff-contracts/src/gcp/legacy-lte.ts
|
|
15205
|
-
import { oc as
|
|
15206
|
-
import { z as
|
|
15207
|
-
var uuid =
|
|
15208
|
-
var legacyLteVersion =
|
|
15209
|
-
var legacyLteUpgrade =
|
|
15262
|
+
import { oc as oc20 } from "@orpc/contract";
|
|
15263
|
+
import { z as z30 } from "zod";
|
|
15264
|
+
var uuid = z30.uuidv4().toLowerCase();
|
|
15265
|
+
var legacyLteVersion = z30.string().max(15).regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/).refine((value) => value.split(".").every((part) => Number(part) <= 255));
|
|
15266
|
+
var legacyLteUpgrade = z30.object({
|
|
15210
15267
|
cycleId: uuid,
|
|
15211
15268
|
targetVersion: legacyLteVersion,
|
|
15212
|
-
state:
|
|
15213
|
-
expiresAt:
|
|
15269
|
+
state: z30.enum(["queued", "dispatched", "expired"]),
|
|
15270
|
+
expiresAt: z30.iso.datetime().nullable()
|
|
15214
15271
|
});
|
|
15215
|
-
var legacyLteOptions =
|
|
15216
|
-
currentVersion:
|
|
15217
|
-
blockedReason:
|
|
15218
|
-
releases:
|
|
15272
|
+
var legacyLteOptions = z30.object({
|
|
15273
|
+
currentVersion: z30.string().nullable(),
|
|
15274
|
+
blockedReason: z30.string().nullable(),
|
|
15275
|
+
releases: z30.array(firmwareRelease.extend({ version: legacyLteVersion })),
|
|
15219
15276
|
upgrade: legacyLteUpgrade.nullable()
|
|
15220
15277
|
});
|
|
15221
15278
|
var legacyLteQueueInput = trackerInput.extend({
|
|
@@ -15230,61 +15287,61 @@ var legacyLteCancelInput = trackerInput.extend({
|
|
|
15230
15287
|
expectedCycleId: uuid
|
|
15231
15288
|
});
|
|
15232
15289
|
var legacyLteOperationInput = trackerInput.extend({ requestId: uuid });
|
|
15233
|
-
var legacyLteOperation =
|
|
15290
|
+
var legacyLteOperation = z30.object({
|
|
15234
15291
|
requestId: uuid,
|
|
15235
|
-
kind:
|
|
15292
|
+
kind: z30.enum(["queue", "cancel"]),
|
|
15236
15293
|
cycleId: uuid,
|
|
15237
15294
|
fromVersion: legacyLteVersion.nullable(),
|
|
15238
15295
|
targetVersion: legacyLteVersion.nullable(),
|
|
15239
|
-
requestedAt:
|
|
15296
|
+
requestedAt: z30.iso.datetime()
|
|
15240
15297
|
});
|
|
15241
|
-
var procedure2 =
|
|
15298
|
+
var procedure2 = oc20.errors(firmwareErrors);
|
|
15242
15299
|
var legacyLteContract = {
|
|
15243
15300
|
options: procedure2.meta({ operation: "read" }).input(trackerInput).output(legacyLteOptions),
|
|
15244
15301
|
queue: procedure2.input(legacyLteQueueInput).output(
|
|
15245
|
-
|
|
15302
|
+
z30.object({
|
|
15246
15303
|
cycleId: uuid,
|
|
15247
15304
|
fromVersion: legacyLteVersion,
|
|
15248
15305
|
targetVersion: legacyLteVersion
|
|
15249
15306
|
})
|
|
15250
15307
|
),
|
|
15251
|
-
cancel: procedure2.input(legacyLteCancelInput).output(
|
|
15308
|
+
cancel: procedure2.input(legacyLteCancelInput).output(z30.object({ cycleId: uuid })),
|
|
15252
15309
|
operation: procedure2.meta({ operation: "read" }).input(legacyLteOperationInput).output(legacyLteOperation)
|
|
15253
15310
|
};
|
|
15254
15311
|
|
|
15255
15312
|
// ../staff-contracts/src/schemas.ts
|
|
15256
|
-
import { z as
|
|
15257
|
-
var staffTrackerSummary =
|
|
15313
|
+
import { z as z31 } from "zod";
|
|
15314
|
+
var staffTrackerSummary = z31.object({
|
|
15258
15315
|
...trackerSummaryFields,
|
|
15259
|
-
hardware:
|
|
15260
|
-
imei:
|
|
15261
|
-
iccid:
|
|
15262
|
-
imsi:
|
|
15263
|
-
serialNumber:
|
|
15316
|
+
hardware: z31.object({
|
|
15317
|
+
imei: z31.string().nullable(),
|
|
15318
|
+
iccid: z31.string().nullable(),
|
|
15319
|
+
imsi: z31.string().nullable(),
|
|
15320
|
+
serialNumber: z31.string().nullable()
|
|
15264
15321
|
}).nullable(),
|
|
15265
|
-
backend:
|
|
15322
|
+
backend: z31.string().nullable()
|
|
15266
15323
|
});
|
|
15267
|
-
var staffTrackerPage =
|
|
15268
|
-
items:
|
|
15269
|
-
nextAfter:
|
|
15324
|
+
var staffTrackerPage = z31.object({
|
|
15325
|
+
items: z31.array(staffTrackerSummary),
|
|
15326
|
+
nextAfter: z31.string().nullable()
|
|
15270
15327
|
});
|
|
15271
|
-
var staffTracker =
|
|
15328
|
+
var staffTracker = z31.object({
|
|
15272
15329
|
...trackerFields,
|
|
15273
15330
|
hardware: staffTrackerSummary.shape.hardware,
|
|
15274
15331
|
backend: staffTrackerSummary.shape.backend,
|
|
15275
|
-
configuration:
|
|
15276
|
-
movementAlerts:
|
|
15277
|
-
isBlacklisted:
|
|
15332
|
+
configuration: z31.object({
|
|
15333
|
+
movementAlerts: z31.boolean().nullable(),
|
|
15334
|
+
isBlacklisted: z31.boolean().nullable()
|
|
15278
15335
|
}).nullable()
|
|
15279
15336
|
});
|
|
15280
15337
|
|
|
15281
15338
|
// ../staff-contracts/src/gcp/diagnostics.ts
|
|
15282
|
-
import { oc as
|
|
15283
|
-
import { z as
|
|
15284
|
-
var number =
|
|
15285
|
-
var integer =
|
|
15286
|
-
var text2 =
|
|
15287
|
-
var boolean3 =
|
|
15339
|
+
import { oc as oc21, eventIterator as eventIterator6 } from "@orpc/contract";
|
|
15340
|
+
import { z as z32 } from "zod";
|
|
15341
|
+
var number = z32.number().nullable();
|
|
15342
|
+
var integer = z32.int().nullable();
|
|
15343
|
+
var text2 = z32.string().nullable();
|
|
15344
|
+
var boolean3 = z32.boolean().nullable();
|
|
15288
15345
|
var trackerBatteryDiagnostics = trackerBattery.extend({
|
|
15289
15346
|
temp: number,
|
|
15290
15347
|
voltage: number,
|
|
@@ -15301,8 +15358,8 @@ var trackerBatteryDiagnostics = trackerBattery.extend({
|
|
|
15301
15358
|
chargerChipStatus: text2,
|
|
15302
15359
|
chargerFaultStatus: text2
|
|
15303
15360
|
});
|
|
15304
|
-
var coordinates =
|
|
15305
|
-
var reportCell =
|
|
15361
|
+
var coordinates = z32.object({ latitude: number, longitude: number });
|
|
15362
|
+
var reportCell = z32.object({
|
|
15306
15363
|
mcc: integer,
|
|
15307
15364
|
mnc: integer,
|
|
15308
15365
|
lac: integer,
|
|
@@ -15316,14 +15373,14 @@ var reportCell = z31.object({
|
|
|
15316
15373
|
timeToConnect: number,
|
|
15317
15374
|
networkType: text2,
|
|
15318
15375
|
get nCells() {
|
|
15319
|
-
return
|
|
15376
|
+
return z32.array(reportCell).nullable();
|
|
15320
15377
|
},
|
|
15321
15378
|
get gciCells() {
|
|
15322
|
-
return
|
|
15379
|
+
return z32.array(reportCell).nullable();
|
|
15323
15380
|
}
|
|
15324
15381
|
});
|
|
15325
|
-
var trackerLatestReport =
|
|
15326
|
-
timestamp:
|
|
15382
|
+
var trackerLatestReport = z32.object({
|
|
15383
|
+
timestamp: z32.iso.datetime().nullable(),
|
|
15327
15384
|
type: text2,
|
|
15328
15385
|
mode: text2,
|
|
15329
15386
|
stage: text2,
|
|
@@ -15370,13 +15427,13 @@ var trackerLatestReport = z31.object({
|
|
|
15370
15427
|
gnssMaxSatsInView: integer
|
|
15371
15428
|
}).nullable(),
|
|
15372
15429
|
geoPoint: coordinates.nullable(),
|
|
15373
|
-
cells:
|
|
15374
|
-
wifi:
|
|
15375
|
-
bleDevs:
|
|
15376
|
-
errorLogs:
|
|
15430
|
+
cells: z32.array(reportCell).nullable(),
|
|
15431
|
+
wifi: z32.array(z32.object({ mac: text2, rssi: number, channel: integer })).nullable(),
|
|
15432
|
+
bleDevs: z32.array(z32.object({ mac: text2, rssi: number, companyId: integer })).nullable(),
|
|
15433
|
+
errorLogs: z32.array(z32.object({ code: text2, numErrors: integer })).nullable()
|
|
15377
15434
|
});
|
|
15378
|
-
var operationStatistics =
|
|
15379
|
-
var trackerStatistics =
|
|
15435
|
+
var operationStatistics = z32.object({ count: integer, successCount: integer, failCount: integer }).nullable();
|
|
15436
|
+
var trackerStatistics = z32.object({
|
|
15380
15437
|
count: integer,
|
|
15381
15438
|
resets: integer,
|
|
15382
15439
|
failedWifi: integer,
|
|
@@ -15392,7 +15449,7 @@ var trackerStatistics = z31.object({
|
|
|
15392
15449
|
averageCellSignalStrength: number,
|
|
15393
15450
|
averageSatsInView: number,
|
|
15394
15451
|
averageGnssFixSnr: number,
|
|
15395
|
-
averageGnssMaxSnr:
|
|
15452
|
+
averageGnssMaxSnr: z32.object({ value: number, count: integer }).nullable(),
|
|
15396
15453
|
oad: operationStatistics,
|
|
15397
15454
|
factoryReset: operationStatistics,
|
|
15398
15455
|
INI: integer,
|
|
@@ -15406,36 +15463,36 @@ var trackerStatistics = z31.object({
|
|
|
15406
15463
|
DEFAULT: integer,
|
|
15407
15464
|
SMT: integer
|
|
15408
15465
|
});
|
|
15409
|
-
var staffTrackerDiagnostics =
|
|
15466
|
+
var staffTrackerDiagnostics = z32.object({
|
|
15410
15467
|
...documentFields,
|
|
15411
15468
|
batteryDiagnostics: trackerBatteryDiagnostics.nullable(),
|
|
15412
15469
|
latestReport: trackerLatestReport.nullable(),
|
|
15413
15470
|
statistics: trackerStatistics.nullable()
|
|
15414
15471
|
});
|
|
15415
|
-
var procedure3 =
|
|
15472
|
+
var procedure3 = oc21.meta({ operation: "read" }).errors(apiErrors).input(trackerInput);
|
|
15416
15473
|
var diagnosticsContract = {
|
|
15417
15474
|
get: procedure3.output(staffTrackerDiagnostics),
|
|
15418
15475
|
watch: procedure3.output(eventIterator6(staffTrackerDiagnostics))
|
|
15419
15476
|
};
|
|
15420
15477
|
|
|
15421
15478
|
// ../staff-contracts/src/gcp/audit.ts
|
|
15422
|
-
import { oc as
|
|
15423
|
-
import { z as
|
|
15424
|
-
var text3 =
|
|
15425
|
-
var integer2 =
|
|
15426
|
-
var time =
|
|
15427
|
-
var scalar =
|
|
15479
|
+
import { oc as oc22 } from "@orpc/contract";
|
|
15480
|
+
import { z as z33 } from "zod";
|
|
15481
|
+
var text3 = z33.string().nullable();
|
|
15482
|
+
var integer2 = z33.int().nullable();
|
|
15483
|
+
var time = z33.iso.datetime().nullable();
|
|
15484
|
+
var scalar = z33.union([z33.string(), z33.number()]).nullable();
|
|
15428
15485
|
var envelope = {
|
|
15429
15486
|
timestamp: time,
|
|
15430
|
-
value:
|
|
15431
|
-
requestedBy:
|
|
15487
|
+
value: z33.boolean().optional(),
|
|
15488
|
+
requestedBy: z33.string().optional()
|
|
15432
15489
|
};
|
|
15433
|
-
var unsupported =
|
|
15490
|
+
var unsupported = z33.object({
|
|
15434
15491
|
...envelope,
|
|
15435
|
-
kind:
|
|
15492
|
+
kind: z33.literal("unsupported"),
|
|
15436
15493
|
type: text3
|
|
15437
15494
|
});
|
|
15438
|
-
var bike =
|
|
15495
|
+
var bike = z33.object({
|
|
15439
15496
|
nickname: text3,
|
|
15440
15497
|
brand: text3,
|
|
15441
15498
|
type: text3,
|
|
@@ -15447,20 +15504,20 @@ var bike = z32.object({
|
|
|
15447
15504
|
receiptImage: text3,
|
|
15448
15505
|
receiptImageThumb: text3
|
|
15449
15506
|
}).partial();
|
|
15450
|
-
var member =
|
|
15451
|
-
active:
|
|
15507
|
+
var member = z33.object({
|
|
15508
|
+
active: z33.boolean().nullable(),
|
|
15452
15509
|
addedBy: text3,
|
|
15453
15510
|
displayName: text3,
|
|
15454
15511
|
description: text3,
|
|
15455
15512
|
listIndex: integer2,
|
|
15456
15513
|
timestamp: time
|
|
15457
15514
|
}).partial();
|
|
15458
|
-
var members =
|
|
15459
|
-
var pin =
|
|
15460
|
-
var textChange =
|
|
15515
|
+
var members = z33.record(z33.string(), member.nullable()).nullable();
|
|
15516
|
+
var pin = z33.array(z33.int().min(0).max(255)).nullable();
|
|
15517
|
+
var textChange = z33.object({
|
|
15461
15518
|
...envelope,
|
|
15462
|
-
kind:
|
|
15463
|
-
type:
|
|
15519
|
+
kind: z33.literal("textChange"),
|
|
15520
|
+
type: z33.enum([
|
|
15464
15521
|
"mode",
|
|
15465
15522
|
"status",
|
|
15466
15523
|
"tiFirmware",
|
|
@@ -15474,45 +15531,45 @@ var textChange = z32.object({
|
|
|
15474
15531
|
old: text3,
|
|
15475
15532
|
new: text3
|
|
15476
15533
|
});
|
|
15477
|
-
var buildChange =
|
|
15534
|
+
var buildChange = z33.object({
|
|
15478
15535
|
...envelope,
|
|
15479
|
-
kind:
|
|
15480
|
-
type:
|
|
15536
|
+
kind: z33.literal("buildChange"),
|
|
15537
|
+
type: z33.literal("buildNumber"),
|
|
15481
15538
|
old: scalar,
|
|
15482
15539
|
new: scalar
|
|
15483
15540
|
});
|
|
15484
|
-
var countChange =
|
|
15541
|
+
var countChange = z33.object({
|
|
15485
15542
|
...envelope,
|
|
15486
|
-
kind:
|
|
15487
|
-
type:
|
|
15543
|
+
kind: z33.literal("countChange"),
|
|
15544
|
+
type: z33.literal("userCount"),
|
|
15488
15545
|
old: integer2,
|
|
15489
15546
|
new: integer2
|
|
15490
15547
|
});
|
|
15491
|
-
var booleanChange =
|
|
15548
|
+
var booleanChange = z33.object({
|
|
15492
15549
|
...envelope,
|
|
15493
|
-
kind:
|
|
15494
|
-
type:
|
|
15495
|
-
old:
|
|
15496
|
-
new:
|
|
15550
|
+
kind: z33.literal("booleanChange"),
|
|
15551
|
+
type: z33.literal("isBlacklisted"),
|
|
15552
|
+
old: z33.boolean().nullable(),
|
|
15553
|
+
new: z33.boolean().nullable()
|
|
15497
15554
|
});
|
|
15498
|
-
var pinChange =
|
|
15555
|
+
var pinChange = z33.object({
|
|
15499
15556
|
...envelope,
|
|
15500
|
-
kind:
|
|
15501
|
-
type:
|
|
15557
|
+
kind: z33.literal("pinChange"),
|
|
15558
|
+
type: z33.literal("blePin"),
|
|
15502
15559
|
old: pin,
|
|
15503
15560
|
new: pin
|
|
15504
15561
|
});
|
|
15505
|
-
var bikeChange =
|
|
15562
|
+
var bikeChange = z33.object({
|
|
15506
15563
|
...envelope,
|
|
15507
|
-
kind:
|
|
15508
|
-
type:
|
|
15564
|
+
kind: z33.literal("bikeChange"),
|
|
15565
|
+
type: z33.literal("bikeInfo"),
|
|
15509
15566
|
old: bike.nullable(),
|
|
15510
15567
|
new: bike.nullable()
|
|
15511
15568
|
});
|
|
15512
|
-
var membersChange =
|
|
15569
|
+
var membersChange = z33.object({
|
|
15513
15570
|
...envelope,
|
|
15514
|
-
kind:
|
|
15515
|
-
type:
|
|
15571
|
+
kind: z33.literal("membersChange"),
|
|
15572
|
+
type: z33.enum(["users", "fleetUsers"]),
|
|
15516
15573
|
old: members,
|
|
15517
15574
|
new: members
|
|
15518
15575
|
});
|
|
@@ -15525,20 +15582,20 @@ var changes = [
|
|
|
15525
15582
|
bikeChange,
|
|
15526
15583
|
membersChange
|
|
15527
15584
|
];
|
|
15528
|
-
var nestedChange =
|
|
15529
|
-
var operation =
|
|
15585
|
+
var nestedChange = z33.discriminatedUnion("kind", [...changes, unsupported]);
|
|
15586
|
+
var operation = z33.object({
|
|
15530
15587
|
type: text3,
|
|
15531
15588
|
timestamp: time,
|
|
15532
|
-
what:
|
|
15533
|
-
|
|
15534
|
-
|
|
15535
|
-
|
|
15536
|
-
|
|
15537
|
-
|
|
15589
|
+
what: z33.discriminatedUnion("kind", [
|
|
15590
|
+
z33.object({ kind: z33.literal("text"), value: z33.string() }),
|
|
15591
|
+
z33.object({ kind: z33.literal("change"), value: nestedChange }),
|
|
15592
|
+
z33.object({ kind: z33.literal("null") }),
|
|
15593
|
+
z33.object({ kind: z33.literal("missing") }),
|
|
15594
|
+
z33.object({ kind: z33.literal("invalid") })
|
|
15538
15595
|
]),
|
|
15539
|
-
doc:
|
|
15596
|
+
doc: z33.object({ id: text3, type: text3, fleetId: text3 }).nullable()
|
|
15540
15597
|
});
|
|
15541
|
-
var diagnostic =
|
|
15598
|
+
var diagnostic = z33.object({
|
|
15542
15599
|
code: text3,
|
|
15543
15600
|
stage: text3,
|
|
15544
15601
|
classification: text3,
|
|
@@ -15550,33 +15607,33 @@ var diagnostic = z32.object({
|
|
|
15550
15607
|
providerStage: text3,
|
|
15551
15608
|
providerState: text3,
|
|
15552
15609
|
responseCode: scalar,
|
|
15553
|
-
outcomeUnknown:
|
|
15610
|
+
outcomeUnknown: z33.boolean().nullable(),
|
|
15554
15611
|
correlationId: text3
|
|
15555
15612
|
});
|
|
15556
|
-
var auditEvent =
|
|
15613
|
+
var auditEvent = z33.discriminatedUnion("kind", [
|
|
15557
15614
|
...changes,
|
|
15558
|
-
|
|
15615
|
+
z33.object({
|
|
15559
15616
|
...envelope,
|
|
15560
|
-
kind:
|
|
15561
|
-
type:
|
|
15617
|
+
kind: z33.literal("message"),
|
|
15618
|
+
type: z33.enum(["info", "error"]),
|
|
15562
15619
|
message: text3,
|
|
15563
15620
|
operationId: text3
|
|
15564
15621
|
}),
|
|
15565
|
-
|
|
15622
|
+
z33.object({
|
|
15566
15623
|
...envelope,
|
|
15567
|
-
kind:
|
|
15568
|
-
type:
|
|
15624
|
+
kind: z33.literal("note"),
|
|
15625
|
+
type: z33.literal("blacklist"),
|
|
15569
15626
|
note: text3
|
|
15570
15627
|
}),
|
|
15571
|
-
|
|
15628
|
+
z33.object({
|
|
15572
15629
|
...envelope,
|
|
15573
|
-
kind:
|
|
15574
|
-
type:
|
|
15630
|
+
kind: z33.literal("action"),
|
|
15631
|
+
type: z33.enum(["clean", "factoryReset", "isBlacklisted"])
|
|
15575
15632
|
}),
|
|
15576
|
-
|
|
15633
|
+
z33.object({
|
|
15577
15634
|
...envelope,
|
|
15578
|
-
kind:
|
|
15579
|
-
type:
|
|
15635
|
+
kind: z33.literal("failure"),
|
|
15636
|
+
type: z33.literal("effectFailure"),
|
|
15580
15637
|
schemaVersion: integer2,
|
|
15581
15638
|
source: text3,
|
|
15582
15639
|
producer: text3,
|
|
@@ -15589,96 +15646,96 @@ var auditEvent = z32.discriminatedUnion("kind", [
|
|
|
15589
15646
|
deviceCreatedAt: time,
|
|
15590
15647
|
diagnostic: diagnostic.nullable()
|
|
15591
15648
|
}),
|
|
15592
|
-
|
|
15649
|
+
z33.object({
|
|
15593
15650
|
...envelope,
|
|
15594
|
-
kind:
|
|
15595
|
-
type:
|
|
15651
|
+
kind: z33.literal("operations"),
|
|
15652
|
+
type: z33.enum(["read", "google.firestore.document.update"]),
|
|
15596
15653
|
old: integer2,
|
|
15597
15654
|
new: integer2,
|
|
15598
15655
|
uid: text3,
|
|
15599
15656
|
logType: text3,
|
|
15600
15657
|
startTimestamp: time,
|
|
15601
15658
|
lastOperation: operation.nullable(),
|
|
15602
|
-
operations:
|
|
15659
|
+
operations: z33.array(operation).nullable()
|
|
15603
15660
|
}),
|
|
15604
15661
|
unsupported
|
|
15605
15662
|
]);
|
|
15606
|
-
var auditEntry =
|
|
15663
|
+
var auditEntry = z33.object({
|
|
15607
15664
|
...documentFields,
|
|
15608
15665
|
event: auditEvent,
|
|
15609
|
-
readIssues:
|
|
15610
|
-
|
|
15611
|
-
path:
|
|
15612
|
-
code:
|
|
15666
|
+
readIssues: z33.array(
|
|
15667
|
+
z33.object({
|
|
15668
|
+
path: z33.string(),
|
|
15669
|
+
code: z33.enum(["unsupported_stored_event_type", "invalid_stored_value"])
|
|
15613
15670
|
})
|
|
15614
15671
|
)
|
|
15615
15672
|
});
|
|
15616
|
-
var auditPage =
|
|
15617
|
-
items:
|
|
15673
|
+
var auditPage = z33.object({
|
|
15674
|
+
items: z33.array(auditEntry),
|
|
15618
15675
|
nextAfter: historyCursor.nullable()
|
|
15619
15676
|
});
|
|
15620
|
-
var auditContract =
|
|
15677
|
+
var auditContract = oc22.meta({ operation: "read" }).errors(apiErrors).input(historyInput).output(auditPage);
|
|
15621
15678
|
|
|
15622
15679
|
// ../staff-contracts/src/subscriptions.ts
|
|
15623
|
-
import { oc as
|
|
15624
|
-
import { z as
|
|
15680
|
+
import { oc as oc23 } from "@orpc/contract";
|
|
15681
|
+
import { z as z34 } from "zod";
|
|
15625
15682
|
var staffSubscription = subscription.extend({
|
|
15626
|
-
email:
|
|
15627
|
-
commerceId:
|
|
15628
|
-
sku:
|
|
15683
|
+
email: z34.string().nullable(),
|
|
15684
|
+
commerceId: z34.int().nullable(),
|
|
15685
|
+
sku: z34.string().nullable()
|
|
15629
15686
|
});
|
|
15630
|
-
var staffSubscriptionPageInput =
|
|
15687
|
+
var staffSubscriptionPageInput = z34.strictObject({
|
|
15631
15688
|
...pageFields,
|
|
15632
15689
|
accountId: documentId.optional(),
|
|
15633
|
-
commerceId:
|
|
15634
|
-
businessEmail:
|
|
15635
|
-
businessOnly:
|
|
15690
|
+
commerceId: z34.int().positive().optional(),
|
|
15691
|
+
businessEmail: z34.email().max(320).optional(),
|
|
15692
|
+
businessOnly: z34.boolean().default(false)
|
|
15636
15693
|
}).prefault({});
|
|
15637
|
-
var staffSubscriptionPage =
|
|
15638
|
-
items:
|
|
15639
|
-
nextAfter:
|
|
15694
|
+
var staffSubscriptionPage = z34.object({
|
|
15695
|
+
items: z34.array(staffSubscription),
|
|
15696
|
+
nextAfter: z34.string().nullable()
|
|
15640
15697
|
});
|
|
15641
15698
|
var staffSubscriptionContract = {
|
|
15642
|
-
get:
|
|
15643
|
-
list:
|
|
15699
|
+
get: oc23.meta({ operation: "read" }).errors(apiErrors).input(subscriptionInput).output(staffSubscription),
|
|
15700
|
+
list: oc23.meta({ operation: "read" }).errors(apiErrors).input(staffSubscriptionPageInput).output(staffSubscriptionPage)
|
|
15644
15701
|
};
|
|
15645
15702
|
|
|
15646
15703
|
// ../staff-contracts/src/trackers.ts
|
|
15647
|
-
import { z as
|
|
15648
|
-
var exactValue =
|
|
15704
|
+
import { z as z35 } from "zod";
|
|
15705
|
+
var exactValue = z35.string().min(1).max(128).refine(
|
|
15649
15706
|
(value) => value.trim().length > 0 && !/\p{Cc}/u.test(value),
|
|
15650
15707
|
"Use one exact tracker filter."
|
|
15651
15708
|
);
|
|
15652
|
-
var staffTrackerFilter =
|
|
15653
|
-
|
|
15654
|
-
|
|
15655
|
-
|
|
15656
|
-
|
|
15657
|
-
|
|
15709
|
+
var staffTrackerFilter = z35.discriminatedUnion("by", [
|
|
15710
|
+
z35.strictObject({ by: z35.literal("serialNumber"), value: exactValue }),
|
|
15711
|
+
z35.strictObject({ by: z35.literal("imei"), value: exactValue }),
|
|
15712
|
+
z35.strictObject({ by: z35.literal("iccid"), value: exactValue }),
|
|
15713
|
+
z35.strictObject({ by: z35.literal("accountId"), value: documentId }),
|
|
15714
|
+
z35.strictObject({ by: z35.literal("subscriptionId"), value: documentId })
|
|
15658
15715
|
]);
|
|
15659
|
-
var staffTrackerPageInput =
|
|
15716
|
+
var staffTrackerPageInput = z35.strictObject({
|
|
15660
15717
|
...pageFields,
|
|
15661
15718
|
filter: staffTrackerFilter.optional()
|
|
15662
15719
|
}).prefault({});
|
|
15663
15720
|
|
|
15664
15721
|
// ../staff-contracts/src/operations.ts
|
|
15665
|
-
import { oc as
|
|
15666
|
-
import { z as
|
|
15722
|
+
import { oc as oc24 } from "@orpc/contract";
|
|
15723
|
+
import { z as z37 } from "zod";
|
|
15667
15724
|
|
|
15668
15725
|
// ../staff-contracts/src/support.ts
|
|
15669
|
-
import { z as
|
|
15670
|
-
var providerId =
|
|
15726
|
+
import { z as z36 } from "zod";
|
|
15727
|
+
var providerId = z36.int().positive();
|
|
15671
15728
|
var supportPageFields = {
|
|
15672
|
-
page:
|
|
15673
|
-
limit:
|
|
15729
|
+
page: z36.int().min(1).max(300).default(1),
|
|
15730
|
+
limit: z36.int().min(1).max(100).default(20)
|
|
15674
15731
|
};
|
|
15675
|
-
var supportTag =
|
|
15732
|
+
var supportTag = z36.string().min(1).max(32).refine(
|
|
15676
15733
|
(value) => value.trim() === value && !/[\p{Cc}]/u.test(value),
|
|
15677
15734
|
"Use an exact tag without control characters."
|
|
15678
15735
|
);
|
|
15679
|
-
var supportEmail =
|
|
15680
|
-
var supportVersion =
|
|
15681
|
-
var supportText = (max) =>
|
|
15736
|
+
var supportEmail = z36.email().max(254).refine((value) => value.trim() === value);
|
|
15737
|
+
var supportVersion = z36.string().regex(/^[a-f0-9]{64}$/);
|
|
15738
|
+
var supportText = (max) => z36.string().min(1).max(max).refine((value) => value.trim().length > 0 && !value.includes("\0"));
|
|
15682
15739
|
var supportReviewFields = {
|
|
15683
15740
|
requestId,
|
|
15684
15741
|
recipient: supportEmail,
|
|
@@ -15687,111 +15744,111 @@ var supportReviewFields = {
|
|
|
15687
15744
|
};
|
|
15688
15745
|
|
|
15689
15746
|
// ../staff-contracts/src/operations.ts
|
|
15690
|
-
var supportOperation =
|
|
15747
|
+
var supportOperation = z37.object({
|
|
15691
15748
|
requestId,
|
|
15692
|
-
kind:
|
|
15693
|
-
status:
|
|
15694
|
-
resource:
|
|
15749
|
+
kind: z37.string().min(1),
|
|
15750
|
+
status: z37.enum(["dispatching", "succeeded", "uncertain", "rejected"]),
|
|
15751
|
+
resource: z37.string().min(1),
|
|
15695
15752
|
providerId: providerId.nullable(),
|
|
15696
|
-
summary:
|
|
15697
|
-
createdAt:
|
|
15698
|
-
updatedAt:
|
|
15753
|
+
summary: z37.string(),
|
|
15754
|
+
createdAt: z37.iso.datetime(),
|
|
15755
|
+
updatedAt: z37.iso.datetime()
|
|
15699
15756
|
});
|
|
15700
|
-
var supportOperationInput =
|
|
15757
|
+
var supportOperationInput = z37.strictObject({ requestId });
|
|
15701
15758
|
var supportOperationContract = {
|
|
15702
|
-
get:
|
|
15759
|
+
get: oc24.meta({ operation: "read" }).errors(supportErrors).input(supportOperationInput).output(supportOperation)
|
|
15703
15760
|
};
|
|
15704
15761
|
|
|
15705
15762
|
// ../staff-contracts/src/commerce.ts
|
|
15706
|
-
import { oc as
|
|
15707
|
-
import { z as
|
|
15708
|
-
var moneyAmount =
|
|
15709
|
-
var commerceLine =
|
|
15763
|
+
import { oc as oc25 } from "@orpc/contract";
|
|
15764
|
+
import { z as z38 } from "zod";
|
|
15765
|
+
var moneyAmount = z38.string().regex(/^-?\d{1,12}(?:\.\d{1,6})?$/);
|
|
15766
|
+
var commerceLine = z38.object({
|
|
15710
15767
|
id: providerId,
|
|
15711
|
-
name:
|
|
15712
|
-
productId:
|
|
15713
|
-
variationId:
|
|
15714
|
-
quantity:
|
|
15768
|
+
name: z38.string(),
|
|
15769
|
+
productId: z38.int().nonnegative(),
|
|
15770
|
+
variationId: z38.int().nonnegative(),
|
|
15771
|
+
quantity: z38.number(),
|
|
15715
15772
|
subtotal: moneyAmount,
|
|
15716
15773
|
subtotalTax: moneyAmount,
|
|
15717
15774
|
total: moneyAmount,
|
|
15718
15775
|
totalTax: moneyAmount,
|
|
15719
|
-
sku:
|
|
15776
|
+
sku: z38.string().nullable()
|
|
15720
15777
|
});
|
|
15721
|
-
var commerceOrder =
|
|
15778
|
+
var commerceOrder = z38.object({
|
|
15722
15779
|
id: providerId,
|
|
15723
|
-
number:
|
|
15724
|
-
status:
|
|
15780
|
+
number: z38.string(),
|
|
15781
|
+
status: z38.string(),
|
|
15725
15782
|
billingEmail: supportEmail,
|
|
15726
|
-
customerId:
|
|
15727
|
-
currency:
|
|
15783
|
+
customerId: z38.int().nonnegative(),
|
|
15784
|
+
currency: z38.string(),
|
|
15728
15785
|
total: moneyAmount,
|
|
15729
15786
|
totalTax: moneyAmount,
|
|
15730
15787
|
shippingTotal: moneyAmount,
|
|
15731
15788
|
discountTotal: moneyAmount,
|
|
15732
|
-
paymentMethod:
|
|
15733
|
-
transactionId:
|
|
15734
|
-
paidAtGmt:
|
|
15735
|
-
modifiedAtGmt:
|
|
15736
|
-
lines:
|
|
15737
|
-
refunds:
|
|
15789
|
+
paymentMethod: z38.string(),
|
|
15790
|
+
transactionId: z38.string().nullable(),
|
|
15791
|
+
paidAtGmt: z38.string().nullable(),
|
|
15792
|
+
modifiedAtGmt: z38.string(),
|
|
15793
|
+
lines: z38.array(commerceLine),
|
|
15794
|
+
refunds: z38.array(z38.object({ id: providerId, total: moneyAmount })),
|
|
15738
15795
|
version: supportVersion,
|
|
15739
|
-
adminUrl:
|
|
15796
|
+
adminUrl: z38.url().nullable()
|
|
15740
15797
|
});
|
|
15741
|
-
var commerceSubscription =
|
|
15798
|
+
var commerceSubscription = z38.object({
|
|
15742
15799
|
id: providerId,
|
|
15743
|
-
status:
|
|
15800
|
+
status: z38.string(),
|
|
15744
15801
|
billingEmail: supportEmail,
|
|
15745
|
-
customerId:
|
|
15746
|
-
parentOrderId:
|
|
15747
|
-
currency:
|
|
15802
|
+
customerId: z38.int().nonnegative(),
|
|
15803
|
+
parentOrderId: z38.int().nonnegative(),
|
|
15804
|
+
currency: z38.string(),
|
|
15748
15805
|
total: moneyAmount,
|
|
15749
|
-
paymentMethod:
|
|
15750
|
-
manualRenewal:
|
|
15751
|
-
billingPeriod:
|
|
15752
|
-
billingInterval:
|
|
15753
|
-
nextPaymentAtGmt:
|
|
15754
|
-
retryAtGmt:
|
|
15755
|
-
endsAtGmt:
|
|
15756
|
-
lines:
|
|
15806
|
+
paymentMethod: z38.string(),
|
|
15807
|
+
manualRenewal: z38.boolean(),
|
|
15808
|
+
billingPeriod: z38.string(),
|
|
15809
|
+
billingInterval: z38.int().positive(),
|
|
15810
|
+
nextPaymentAtGmt: z38.string().nullable(),
|
|
15811
|
+
retryAtGmt: z38.string().nullable(),
|
|
15812
|
+
endsAtGmt: z38.string().nullable(),
|
|
15813
|
+
lines: z38.array(commerceLine),
|
|
15757
15814
|
version: supportVersion,
|
|
15758
|
-
adminUrl:
|
|
15815
|
+
adminUrl: z38.url().nullable()
|
|
15759
15816
|
});
|
|
15760
|
-
var commerceNote =
|
|
15817
|
+
var commerceNote = z38.object({
|
|
15761
15818
|
id: providerId,
|
|
15762
|
-
text:
|
|
15763
|
-
author:
|
|
15764
|
-
customerNote:
|
|
15765
|
-
createdAtGmt:
|
|
15819
|
+
text: z38.string(),
|
|
15820
|
+
author: z38.string().nullable(),
|
|
15821
|
+
customerNote: z38.boolean(),
|
|
15822
|
+
createdAtGmt: z38.string()
|
|
15766
15823
|
});
|
|
15767
|
-
var commerceRefund =
|
|
15824
|
+
var commerceRefund = z38.object({
|
|
15768
15825
|
id: providerId,
|
|
15769
15826
|
amount: moneyAmount,
|
|
15770
|
-
reason:
|
|
15771
|
-
processorRefunded:
|
|
15827
|
+
reason: z38.string(),
|
|
15828
|
+
processorRefunded: z38.boolean()
|
|
15772
15829
|
});
|
|
15773
|
-
var refundCapacity =
|
|
15830
|
+
var refundCapacity = z38.object({
|
|
15774
15831
|
orderId: providerId,
|
|
15775
|
-
currency:
|
|
15832
|
+
currency: z38.string(),
|
|
15776
15833
|
remainingAmount: moneyAmount,
|
|
15777
|
-
priceDecimals:
|
|
15778
|
-
paymentMethod:
|
|
15779
|
-
processorSupportsRefunds:
|
|
15780
|
-
refundIds:
|
|
15834
|
+
priceDecimals: z38.int().min(0).max(6),
|
|
15835
|
+
paymentMethod: z38.string(),
|
|
15836
|
+
processorSupportsRefunds: z38.boolean(),
|
|
15837
|
+
refundIds: z38.array(providerId),
|
|
15781
15838
|
version: supportVersion
|
|
15782
15839
|
});
|
|
15783
|
-
var commerceRefundReview =
|
|
15840
|
+
var commerceRefundReview = z38.object({
|
|
15784
15841
|
capacity: refundCapacity,
|
|
15785
|
-
refunds:
|
|
15842
|
+
refunds: z38.array(commerceRefund)
|
|
15786
15843
|
});
|
|
15787
|
-
var commerceRelationships =
|
|
15788
|
-
resource:
|
|
15844
|
+
var commerceRelationships = z38.object({
|
|
15845
|
+
resource: z38.enum(["order", "subscription"]),
|
|
15789
15846
|
id: providerId,
|
|
15790
|
-
items:
|
|
15791
|
-
|
|
15847
|
+
items: z38.array(
|
|
15848
|
+
z38.object({ id: providerId, orderType: z38.string().nullable() })
|
|
15792
15849
|
)
|
|
15793
15850
|
});
|
|
15794
|
-
var commerceQuery =
|
|
15851
|
+
var commerceQuery = z38.strictObject({
|
|
15795
15852
|
...supportPageFields,
|
|
15796
15853
|
email: supportEmail.optional(),
|
|
15797
15854
|
search: supportText(200).optional()
|
|
@@ -15799,35 +15856,35 @@ var commerceQuery = z37.strictObject({
|
|
|
15799
15856
|
(input) => input.email === void 0 || input.search === void 0,
|
|
15800
15857
|
"Use exact billing email or a discovery search, never both."
|
|
15801
15858
|
).prefault({});
|
|
15802
|
-
var commerceId =
|
|
15859
|
+
var commerceId = z38.strictObject({ id: providerId });
|
|
15803
15860
|
var commerceNotesInput = commerceId.extend(supportPageFields);
|
|
15804
|
-
var page2 = (item) =>
|
|
15805
|
-
items:
|
|
15806
|
-
nextPage:
|
|
15807
|
-
truncated:
|
|
15861
|
+
var page2 = (item) => z38.object({
|
|
15862
|
+
items: z38.array(item),
|
|
15863
|
+
nextPage: z38.int().positive().nullable(),
|
|
15864
|
+
truncated: z38.boolean()
|
|
15808
15865
|
});
|
|
15809
|
-
var read =
|
|
15866
|
+
var read = oc25.meta({ operation: "read" }).errors(supportErrors).input(commerceId);
|
|
15810
15867
|
var commerceContract = {
|
|
15811
15868
|
orders: {
|
|
15812
15869
|
get: read.output(commerceOrder),
|
|
15813
|
-
list:
|
|
15814
|
-
notes:
|
|
15870
|
+
list: oc25.meta({ operation: "read" }).errors(supportErrors).input(commerceQuery).output(page2(commerceOrder)),
|
|
15871
|
+
notes: oc25.meta({ operation: "read" }).errors(supportErrors).input(commerceNotesInput).output(page2(commerceNote)),
|
|
15815
15872
|
relationships: read.output(commerceRelationships),
|
|
15816
15873
|
refundReview: read.output(commerceRefundReview),
|
|
15817
|
-
refund:
|
|
15874
|
+
refund: oc25.meta({ operation: "read" }).errors(supportErrors).input(commerceId.extend({ refundId: providerId })).output(commerceRefund)
|
|
15818
15875
|
},
|
|
15819
15876
|
subscriptions: {
|
|
15820
15877
|
get: read.output(commerceSubscription),
|
|
15821
|
-
list:
|
|
15822
|
-
notes:
|
|
15878
|
+
list: oc25.meta({ operation: "read" }).errors(supportErrors).input(commerceQuery).output(page2(commerceSubscription)),
|
|
15879
|
+
notes: oc25.meta({ operation: "read" }).errors(supportErrors).input(commerceNotesInput).output(page2(commerceNote)),
|
|
15823
15880
|
relationships: read.output(commerceRelationships)
|
|
15824
15881
|
}
|
|
15825
15882
|
};
|
|
15826
15883
|
|
|
15827
15884
|
// ../staff-contracts/src/billing.ts
|
|
15828
|
-
import { oc as
|
|
15829
|
-
import { z as
|
|
15830
|
-
var billingReview =
|
|
15885
|
+
import { oc as oc26 } from "@orpc/contract";
|
|
15886
|
+
import { z as z39 } from "zod";
|
|
15887
|
+
var billingReview = z39.strictObject({
|
|
15831
15888
|
requestId,
|
|
15832
15889
|
ticketId: providerId,
|
|
15833
15890
|
recipient: supportEmail,
|
|
@@ -15835,53 +15892,53 @@ var billingReview = z38.strictObject({
|
|
|
15835
15892
|
resourceVersion: supportVersion,
|
|
15836
15893
|
summary: supportText(2e3)
|
|
15837
15894
|
});
|
|
15838
|
-
var reviewedResource =
|
|
15895
|
+
var reviewedResource = z39.strictObject({
|
|
15839
15896
|
id: providerId,
|
|
15840
15897
|
review: billingReview
|
|
15841
15898
|
});
|
|
15842
15899
|
var orderStatusChange = reviewedResource.extend({
|
|
15843
|
-
status:
|
|
15900
|
+
status: z39.string().regex(/^[A-Za-z0-9_-]{1,100}$/).refine((value) => !value.startsWith("wc-"))
|
|
15844
15901
|
});
|
|
15845
15902
|
var subscriptionCancellation = reviewedResource.extend({
|
|
15846
|
-
mode:
|
|
15903
|
+
mode: z39.enum(["endOfTerm", "immediate"])
|
|
15847
15904
|
});
|
|
15848
15905
|
var subscriptionCustomerChange = reviewedResource.extend({
|
|
15849
15906
|
email: supportEmail
|
|
15850
15907
|
});
|
|
15851
15908
|
var subscriptionPaymentChange = reviewedResource.extend({
|
|
15852
|
-
nextPaymentAt:
|
|
15909
|
+
nextPaymentAt: z39.iso.datetime({ offset: true }).refine((value) => {
|
|
15853
15910
|
const fraction = value.match(/\.(\d+)/)?.[1];
|
|
15854
15911
|
return !fraction || /^0+$/.test(fraction);
|
|
15855
15912
|
}, "Use a whole-second payment date.").transform((value) => new Date(value).toISOString())
|
|
15856
15913
|
});
|
|
15857
15914
|
var orderRefund = reviewedResource.extend({
|
|
15858
15915
|
amount: moneyAmount,
|
|
15859
|
-
currency:
|
|
15916
|
+
currency: z39.string().min(1).max(12),
|
|
15860
15917
|
reason: supportText(500)
|
|
15861
15918
|
});
|
|
15862
15919
|
var billingContract = {
|
|
15863
|
-
orderStatus:
|
|
15864
|
-
subscriptionCancel:
|
|
15865
|
-
subscriptionCustomer:
|
|
15866
|
-
subscriptionPayment:
|
|
15867
|
-
refund:
|
|
15920
|
+
orderStatus: oc26.errors(supportErrors).input(orderStatusChange).output(supportOperation),
|
|
15921
|
+
subscriptionCancel: oc26.errors(supportErrors).input(subscriptionCancellation).output(supportOperation),
|
|
15922
|
+
subscriptionCustomer: oc26.errors(supportErrors).input(subscriptionCustomerChange).output(supportOperation),
|
|
15923
|
+
subscriptionPayment: oc26.errors(supportErrors).input(subscriptionPaymentChange).output(supportOperation),
|
|
15924
|
+
refund: oc26.errors(supportErrors).input(orderRefund).output(supportOperation)
|
|
15868
15925
|
};
|
|
15869
15926
|
|
|
15870
15927
|
// ../staff-contracts/src/knowledge.ts
|
|
15871
|
-
import { oc as
|
|
15872
|
-
import { z as
|
|
15873
|
-
var supportPolicy =
|
|
15874
|
-
version:
|
|
15875
|
-
markdown:
|
|
15928
|
+
import { oc as oc27 } from "@orpc/contract";
|
|
15929
|
+
import { z as z40 } from "zod";
|
|
15930
|
+
var supportPolicy = z40.object({
|
|
15931
|
+
version: z40.literal(3),
|
|
15932
|
+
markdown: z40.string().min(1),
|
|
15876
15933
|
sha256: supportVersion,
|
|
15877
|
-
manualUrl:
|
|
15934
|
+
manualUrl: z40.url()
|
|
15878
15935
|
});
|
|
15879
|
-
var supportArticle =
|
|
15936
|
+
var supportArticle = z40.object({
|
|
15880
15937
|
id: providerId,
|
|
15881
|
-
title:
|
|
15882
|
-
text:
|
|
15883
|
-
url:
|
|
15884
|
-
modifiedAt:
|
|
15938
|
+
title: z40.string(),
|
|
15939
|
+
text: z40.string(),
|
|
15940
|
+
url: z40.url().nullable(),
|
|
15941
|
+
modifiedAt: z40.iso.datetime()
|
|
15885
15942
|
});
|
|
15886
15943
|
var articleCandidate = supportArticle.pick({
|
|
15887
15944
|
id: true,
|
|
@@ -15889,130 +15946,130 @@ var articleCandidate = supportArticle.pick({
|
|
|
15889
15946
|
url: true
|
|
15890
15947
|
});
|
|
15891
15948
|
var knowledgeContract = {
|
|
15892
|
-
policy:
|
|
15893
|
-
article:
|
|
15894
|
-
search:
|
|
15895
|
-
|
|
15896
|
-
items:
|
|
15897
|
-
isExhaustive:
|
|
15949
|
+
policy: oc27.meta({ operation: "read" }).errors(supportErrors).output(supportPolicy),
|
|
15950
|
+
article: oc27.meta({ operation: "read" }).errors(supportErrors).input(z40.strictObject({ id: providerId })).output(supportArticle),
|
|
15951
|
+
search: oc27.meta({ operation: "read" }).errors(supportErrors).input(z40.strictObject({ search: supportText(120) })).output(
|
|
15952
|
+
z40.object({
|
|
15953
|
+
items: z40.array(articleCandidate).max(5),
|
|
15954
|
+
isExhaustive: z40.literal(false)
|
|
15898
15955
|
})
|
|
15899
15956
|
)
|
|
15900
15957
|
};
|
|
15901
15958
|
|
|
15902
15959
|
// ../staff-contracts/src/logins.ts
|
|
15903
|
-
import { oc as
|
|
15904
|
-
import { z as
|
|
15905
|
-
var loginEvent =
|
|
15906
|
-
id:
|
|
15907
|
-
type:
|
|
15908
|
-
description:
|
|
15909
|
-
clientId:
|
|
15910
|
-
accountId:
|
|
15960
|
+
import { oc as oc28 } from "@orpc/contract";
|
|
15961
|
+
import { z as z41 } from "zod";
|
|
15962
|
+
var loginEvent = z41.object({
|
|
15963
|
+
id: z41.string().min(1),
|
|
15964
|
+
type: z41.enum(["s", "f", "cs", "cls", "fepotpft"]),
|
|
15965
|
+
description: z41.string().nullable(),
|
|
15966
|
+
clientId: z41.string().nullable(),
|
|
15967
|
+
accountId: z41.string().nullable(),
|
|
15911
15968
|
email: supportEmail,
|
|
15912
|
-
observedAt:
|
|
15969
|
+
observedAt: z41.iso.datetime()
|
|
15913
15970
|
});
|
|
15914
|
-
var loginQuery =
|
|
15971
|
+
var loginQuery = z41.strictObject({
|
|
15915
15972
|
email: supportEmail,
|
|
15916
|
-
from:
|
|
15917
|
-
until:
|
|
15918
|
-
page:
|
|
15919
|
-
});
|
|
15920
|
-
var loginContract =
|
|
15921
|
-
|
|
15922
|
-
items:
|
|
15923
|
-
nextPage:
|
|
15924
|
-
truncated:
|
|
15973
|
+
from: z41.iso.datetime(),
|
|
15974
|
+
until: z41.iso.datetime(),
|
|
15975
|
+
page: z41.int().min(1).max(50).default(1)
|
|
15976
|
+
});
|
|
15977
|
+
var loginContract = oc28.meta({ operation: "read" }).errors(supportErrors).input(loginQuery).output(
|
|
15978
|
+
z41.object({
|
|
15979
|
+
items: z41.array(loginEvent).max(20),
|
|
15980
|
+
nextPage: z41.int().positive().nullable(),
|
|
15981
|
+
truncated: z41.boolean()
|
|
15925
15982
|
})
|
|
15926
15983
|
);
|
|
15927
15984
|
|
|
15928
15985
|
// ../staff-contracts/src/tickets.ts
|
|
15929
|
-
import { oc as
|
|
15930
|
-
import { z as
|
|
15986
|
+
import { oc as oc29 } from "@orpc/contract";
|
|
15987
|
+
import { z as z42 } from "zod";
|
|
15931
15988
|
var ticketAttachmentDownload = downloadReference.extend({
|
|
15932
15989
|
sha256: supportVersion
|
|
15933
15990
|
});
|
|
15934
|
-
var ticketAttachment =
|
|
15991
|
+
var ticketAttachment = z42.object({
|
|
15935
15992
|
id: providerId,
|
|
15936
|
-
name:
|
|
15937
|
-
contentType:
|
|
15938
|
-
size:
|
|
15993
|
+
name: z42.string(),
|
|
15994
|
+
contentType: z42.string(),
|
|
15995
|
+
size: z42.int().nonnegative()
|
|
15939
15996
|
});
|
|
15940
|
-
var ticketSummary =
|
|
15997
|
+
var ticketSummary = z42.object({
|
|
15941
15998
|
id: providerId,
|
|
15942
|
-
subject:
|
|
15943
|
-
status:
|
|
15944
|
-
priority:
|
|
15999
|
+
subject: z42.string(),
|
|
16000
|
+
status: z42.int().positive(),
|
|
16001
|
+
priority: z42.int(),
|
|
15945
16002
|
requesterId: providerId,
|
|
15946
|
-
groupId:
|
|
15947
|
-
agentId:
|
|
15948
|
-
tags:
|
|
15949
|
-
updatedAt:
|
|
16003
|
+
groupId: z42.int().nullable(),
|
|
16004
|
+
agentId: z42.int().nullable(),
|
|
16005
|
+
tags: z42.array(z42.string()),
|
|
16006
|
+
updatedAt: z42.iso.datetime()
|
|
15950
16007
|
});
|
|
15951
|
-
var ticketMessage =
|
|
16008
|
+
var ticketMessage = z42.object({
|
|
15952
16009
|
id: providerId,
|
|
15953
|
-
agentId:
|
|
15954
|
-
incoming:
|
|
15955
|
-
private:
|
|
15956
|
-
text:
|
|
15957
|
-
createdAt:
|
|
15958
|
-
to:
|
|
15959
|
-
cc:
|
|
15960
|
-
bcc:
|
|
15961
|
-
attachments:
|
|
15962
|
-
});
|
|
15963
|
-
var ticketContext =
|
|
16010
|
+
agentId: z42.int().nullable(),
|
|
16011
|
+
incoming: z42.boolean(),
|
|
16012
|
+
private: z42.boolean(),
|
|
16013
|
+
text: z42.string().nullable(),
|
|
16014
|
+
createdAt: z42.iso.datetime(),
|
|
16015
|
+
to: z42.array(z42.string()),
|
|
16016
|
+
cc: z42.array(z42.string()),
|
|
16017
|
+
bcc: z42.array(z42.string()),
|
|
16018
|
+
attachments: z42.array(ticketAttachment)
|
|
16019
|
+
});
|
|
16020
|
+
var ticketContext = z42.object({
|
|
15964
16021
|
ticket: ticketSummary,
|
|
15965
16022
|
requesterEmail: supportEmail,
|
|
15966
|
-
description:
|
|
15967
|
-
attachments:
|
|
15968
|
-
messages:
|
|
15969
|
-
version:
|
|
16023
|
+
description: z42.string().nullable(),
|
|
16024
|
+
attachments: z42.array(ticketAttachment),
|
|
16025
|
+
messages: z42.array(ticketMessage),
|
|
16026
|
+
version: z42.string().regex(/^[a-f0-9]{64}$/)
|
|
15970
16027
|
});
|
|
15971
|
-
var ticketInput =
|
|
15972
|
-
var ticketQuery =
|
|
16028
|
+
var ticketInput = z42.strictObject({ id: providerId });
|
|
16029
|
+
var ticketQuery = z42.strictObject({
|
|
15973
16030
|
...supportPageFields,
|
|
15974
16031
|
email: supportEmail.optional(),
|
|
15975
|
-
updatedSince:
|
|
15976
|
-
order:
|
|
15977
|
-
statuses:
|
|
15978
|
-
excludeTags:
|
|
15979
|
-
groupId:
|
|
15980
|
-
agentId:
|
|
16032
|
+
updatedSince: z42.iso.datetime().optional(),
|
|
16033
|
+
order: z42.enum(["newest", "oldest", "recentlyUpdated", "leastRecentlyUpdated"]).default("newest"),
|
|
16034
|
+
statuses: z42.array(z42.int().positive()).max(20).optional(),
|
|
16035
|
+
excludeTags: z42.array(supportTag).max(40).refine((tags) => new Set(tags).size === tags.length).optional(),
|
|
16036
|
+
groupId: z42.int().nonnegative().optional(),
|
|
16037
|
+
agentId: z42.int().nonnegative().optional()
|
|
15981
16038
|
}).prefault({});
|
|
15982
|
-
var ticketPage =
|
|
15983
|
-
items:
|
|
15984
|
-
nextPage:
|
|
15985
|
-
truncated:
|
|
16039
|
+
var ticketPage = z42.object({
|
|
16040
|
+
items: z42.array(ticketSummary),
|
|
16041
|
+
nextPage: z42.int().positive().nullable(),
|
|
16042
|
+
truncated: z42.boolean()
|
|
15986
16043
|
});
|
|
15987
|
-
var ticketClosure =
|
|
16044
|
+
var ticketClosure = z42.strictObject({
|
|
15988
16045
|
id: providerId,
|
|
15989
16046
|
...supportReviewFields
|
|
15990
16047
|
});
|
|
15991
16048
|
var ticketReply = ticketClosure.extend({ text: supportText(8e3) });
|
|
15992
16049
|
var ticketTagChange = ticketClosure.extend({
|
|
15993
|
-
add:
|
|
15994
|
-
remove:
|
|
16050
|
+
add: z42.array(supportTag).max(40),
|
|
16051
|
+
remove: z42.array(supportTag).max(40)
|
|
15995
16052
|
}).refine(({ add, remove }) => {
|
|
15996
16053
|
const all = [...add, ...remove];
|
|
15997
16054
|
return all.length > 0 && all.length <= 40 && new Set(all).size === all.length;
|
|
15998
16055
|
}, "Supply distinct, nonoverlapping tag additions and removals.");
|
|
15999
16056
|
var ticketContract = {
|
|
16000
|
-
attachment:
|
|
16001
|
-
reply:
|
|
16002
|
-
close:
|
|
16003
|
-
tags:
|
|
16004
|
-
list:
|
|
16005
|
-
get:
|
|
16057
|
+
attachment: oc29.meta({ operation: "read" }).errors(supportErrors).input(ticketInput.extend({ attachmentId: providerId })).output(ticketAttachmentDownload),
|
|
16058
|
+
reply: oc29.errors(supportErrors).input(ticketReply).output(supportOperation),
|
|
16059
|
+
close: oc29.errors(supportErrors).input(ticketClosure).output(supportOperation),
|
|
16060
|
+
tags: oc29.errors(supportErrors).input(ticketTagChange).output(supportOperation),
|
|
16061
|
+
list: oc29.meta({ operation: "read" }).errors(supportErrors).input(ticketQuery).output(ticketPage),
|
|
16062
|
+
get: oc29.meta({ operation: "read" }).errors(supportErrors).input(ticketInput).output(ticketContext)
|
|
16006
16063
|
};
|
|
16007
16064
|
|
|
16008
16065
|
// ../staff-contracts/src/index.ts
|
|
16009
|
-
import { eventIterator as eventIterator7, oc as
|
|
16010
|
-
import { z as
|
|
16066
|
+
import { eventIterator as eventIterator7, oc as oc31 } from "@orpc/contract";
|
|
16067
|
+
import { z as z43 } from "zod";
|
|
16011
16068
|
|
|
16012
16069
|
// ../staff-contracts/src/aws/inventory.ts
|
|
16013
|
-
import { oc as
|
|
16070
|
+
import { oc as oc30 } from "@orpc/contract";
|
|
16014
16071
|
var inventoryContract = {
|
|
16015
|
-
resolve:
|
|
16072
|
+
resolve: oc30.meta({ operation: "read" }).errors(apiErrors).input(deviceLookupInput).output(deviceRegistration.strip())
|
|
16016
16073
|
};
|
|
16017
16074
|
|
|
16018
16075
|
// ../staff-contracts/src/aws/index.ts
|
|
@@ -16039,20 +16096,21 @@ var gcpContract = {
|
|
|
16039
16096
|
};
|
|
16040
16097
|
|
|
16041
16098
|
// ../staff-contracts/src/index.ts
|
|
16042
|
-
var procedure4 =
|
|
16099
|
+
var procedure4 = oc31.errors(apiErrors).input(trackerInput);
|
|
16043
16100
|
var trackerContract = {
|
|
16044
16101
|
subscription: subscriptionAllocationContract,
|
|
16045
16102
|
photos: trackerPhotoContract,
|
|
16046
16103
|
...trackerChangeContract,
|
|
16047
16104
|
members: {
|
|
16048
16105
|
...trackerChangeContract.members,
|
|
16049
|
-
add:
|
|
16106
|
+
add: oc31.errors(apiErrors).input(trackerMemberAddInput).output(z43.void())
|
|
16050
16107
|
},
|
|
16051
|
-
list:
|
|
16108
|
+
list: oc31.meta({ operation: "read" }).errors(apiErrors).input(staffTrackerPageInput).output(staffTrackerPage),
|
|
16052
16109
|
get: procedure4.meta({ operation: "read" }).output(staffTracker),
|
|
16053
16110
|
watch: procedure4.meta({ operation: "read" }).output(eventIterator7(staffTracker))
|
|
16054
16111
|
};
|
|
16055
16112
|
var staffContract = {
|
|
16113
|
+
firmware: firmwareCatalogContract,
|
|
16056
16114
|
realtime: realtimeContract,
|
|
16057
16115
|
subscriptions: staffSubscriptionContract,
|
|
16058
16116
|
favorites: favoriteContract,
|
|
@@ -16130,6 +16188,15 @@ export {
|
|
|
16130
16188
|
favoriteWrite,
|
|
16131
16189
|
favoriteInput,
|
|
16132
16190
|
favoriteContract,
|
|
16191
|
+
firmwareCatalogFamily,
|
|
16192
|
+
firmwareCatalogCapability,
|
|
16193
|
+
maximumFirmwareUploadBytes,
|
|
16194
|
+
catalogFirmwareVersion,
|
|
16195
|
+
firmwareCatalogUploadInput,
|
|
16196
|
+
firmwareCatalogPublishInput,
|
|
16197
|
+
firmwareCatalogRelease,
|
|
16198
|
+
firmwareCatalogInput,
|
|
16199
|
+
firmwareCatalogContract,
|
|
16133
16200
|
maintenanceInput,
|
|
16134
16201
|
denylistInput,
|
|
16135
16202
|
maintenanceAccepted,
|