@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.
@@ -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: z21.string().regex(/^(slot:[0-7]|msp430:[0-9a-f]{16})$/),
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/gcp/maintenance.ts
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 maintenanceInput = z27.strictObject({
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: z27.boolean()
15223
+ blacklisted: z28.boolean()
15167
15224
  });
15168
- var maintenanceAccepted = z27.object({
15225
+ var maintenanceAccepted = z28.object({
15169
15226
  deviceId: documentId,
15170
15227
  requestId
15171
15228
  });
15172
- var operationExecution = z27.object({
15173
- state: z27.string().nullable(),
15174
- attempts: z27.int().nullable(),
15175
- finishedAt: z27.iso.datetime().nullable()
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 = z27.object({
15234
+ var maintenanceOperation = z28.object({
15178
15235
  ...documentFields,
15179
15236
  deviceId: documentId,
15180
- trackerCreatedAt: z27.iso.datetime(),
15181
- operation: z27.enum(["clean", "denylist"]),
15182
- jobId: z27.string().regex(/^[a-f0-9]{64}$/).nullable(),
15183
- requestedBy: z27.string().nullable(),
15184
- acceptedAt: z27.iso.datetime().nullable(),
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: oc17.errors(apiErrors).input(maintenanceInput).output(maintenanceAccepted),
15189
- setDenylist: oc17.errors(apiErrors).input(denylistInput).output(maintenanceAccepted),
15190
- get: oc17.meta({ operation: "read" }).errors(apiErrors).input(maintenanceInput).output(maintenanceOperation)
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 oc18 } from "@orpc/contract";
15195
- import { z as z28 } from "zod";
15196
- var simStatus = z28.object({
15197
- iccid: z28.string().regex(/^[0-9]{18,22}$/),
15198
- found: z28.boolean(),
15199
- status: z28.string().nullable(),
15200
- checkedAt: z28.iso.datetime()
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 = oc18.meta({ operation: "read" }).errors(apiErrors).input(trackerInput).output(simStatus);
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 oc19 } from "@orpc/contract";
15206
- import { z as z29 } from "zod";
15207
- var uuid = z29.uuidv4().toLowerCase();
15208
- var legacyLteVersion = z29.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));
15209
- var legacyLteUpgrade = z29.object({
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: z29.enum(["queued", "dispatched", "expired"]),
15213
- expiresAt: z29.iso.datetime().nullable()
15269
+ state: z30.enum(["queued", "dispatched", "expired"]),
15270
+ expiresAt: z30.iso.datetime().nullable()
15214
15271
  });
15215
- var legacyLteOptions = z29.object({
15216
- currentVersion: z29.string().nullable(),
15217
- blockedReason: z29.string().nullable(),
15218
- releases: z29.array(firmwareRelease.extend({ version: legacyLteVersion })),
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 = z29.object({
15290
+ var legacyLteOperation = z30.object({
15234
15291
  requestId: uuid,
15235
- kind: z29.enum(["queue", "cancel"]),
15292
+ kind: z30.enum(["queue", "cancel"]),
15236
15293
  cycleId: uuid,
15237
15294
  fromVersion: legacyLteVersion.nullable(),
15238
15295
  targetVersion: legacyLteVersion.nullable(),
15239
- requestedAt: z29.iso.datetime()
15296
+ requestedAt: z30.iso.datetime()
15240
15297
  });
15241
- var procedure2 = oc19.errors(firmwareErrors);
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
- z29.object({
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(z29.object({ cycleId: uuid })),
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 z30 } from "zod";
15257
- var staffTrackerSummary = z30.object({
15313
+ import { z as z31 } from "zod";
15314
+ var staffTrackerSummary = z31.object({
15258
15315
  ...trackerSummaryFields,
15259
- hardware: z30.object({
15260
- imei: z30.string().nullable(),
15261
- iccid: z30.string().nullable(),
15262
- imsi: z30.string().nullable(),
15263
- serialNumber: z30.string().nullable()
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: z30.string().nullable()
15322
+ backend: z31.string().nullable()
15266
15323
  });
15267
- var staffTrackerPage = z30.object({
15268
- items: z30.array(staffTrackerSummary),
15269
- nextAfter: z30.string().nullable()
15324
+ var staffTrackerPage = z31.object({
15325
+ items: z31.array(staffTrackerSummary),
15326
+ nextAfter: z31.string().nullable()
15270
15327
  });
15271
- var staffTracker = z30.object({
15328
+ var staffTracker = z31.object({
15272
15329
  ...trackerFields,
15273
15330
  hardware: staffTrackerSummary.shape.hardware,
15274
15331
  backend: staffTrackerSummary.shape.backend,
15275
- configuration: z30.object({
15276
- movementAlerts: z30.boolean().nullable(),
15277
- isBlacklisted: z30.boolean().nullable()
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 oc20, eventIterator as eventIterator6 } from "@orpc/contract";
15283
- import { z as z31 } from "zod";
15284
- var number = z31.number().nullable();
15285
- var integer = z31.int().nullable();
15286
- var text2 = z31.string().nullable();
15287
- var boolean3 = z31.boolean().nullable();
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 = z31.object({ latitude: number, longitude: number });
15305
- var reportCell = z31.object({
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 z31.array(reportCell).nullable();
15376
+ return z32.array(reportCell).nullable();
15320
15377
  },
15321
15378
  get gciCells() {
15322
- return z31.array(reportCell).nullable();
15379
+ return z32.array(reportCell).nullable();
15323
15380
  }
15324
15381
  });
15325
- var trackerLatestReport = z31.object({
15326
- timestamp: z31.iso.datetime().nullable(),
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: z31.array(reportCell).nullable(),
15374
- wifi: z31.array(z31.object({ mac: text2, rssi: number, channel: integer })).nullable(),
15375
- bleDevs: z31.array(z31.object({ mac: text2, rssi: number, companyId: integer })).nullable(),
15376
- errorLogs: z31.array(z31.object({ code: text2, numErrors: integer })).nullable()
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 = z31.object({ count: integer, successCount: integer, failCount: integer }).nullable();
15379
- var trackerStatistics = z31.object({
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: z31.object({ value: number, count: integer }).nullable(),
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 = z31.object({
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 = oc20.meta({ operation: "read" }).errors(apiErrors).input(trackerInput);
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 oc21 } from "@orpc/contract";
15423
- import { z as z32 } from "zod";
15424
- var text3 = z32.string().nullable();
15425
- var integer2 = z32.int().nullable();
15426
- var time = z32.iso.datetime().nullable();
15427
- var scalar = z32.union([z32.string(), z32.number()]).nullable();
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: z32.boolean().optional(),
15431
- requestedBy: z32.string().optional()
15487
+ value: z33.boolean().optional(),
15488
+ requestedBy: z33.string().optional()
15432
15489
  };
15433
- var unsupported = z32.object({
15490
+ var unsupported = z33.object({
15434
15491
  ...envelope,
15435
- kind: z32.literal("unsupported"),
15492
+ kind: z33.literal("unsupported"),
15436
15493
  type: text3
15437
15494
  });
15438
- var bike = z32.object({
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 = z32.object({
15451
- active: z32.boolean().nullable(),
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 = z32.record(z32.string(), member.nullable()).nullable();
15459
- var pin = z32.array(z32.int().min(0).max(255)).nullable();
15460
- var textChange = z32.object({
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: z32.literal("textChange"),
15463
- type: z32.enum([
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 = z32.object({
15534
+ var buildChange = z33.object({
15478
15535
  ...envelope,
15479
- kind: z32.literal("buildChange"),
15480
- type: z32.literal("buildNumber"),
15536
+ kind: z33.literal("buildChange"),
15537
+ type: z33.literal("buildNumber"),
15481
15538
  old: scalar,
15482
15539
  new: scalar
15483
15540
  });
15484
- var countChange = z32.object({
15541
+ var countChange = z33.object({
15485
15542
  ...envelope,
15486
- kind: z32.literal("countChange"),
15487
- type: z32.literal("userCount"),
15543
+ kind: z33.literal("countChange"),
15544
+ type: z33.literal("userCount"),
15488
15545
  old: integer2,
15489
15546
  new: integer2
15490
15547
  });
15491
- var booleanChange = z32.object({
15548
+ var booleanChange = z33.object({
15492
15549
  ...envelope,
15493
- kind: z32.literal("booleanChange"),
15494
- type: z32.literal("isBlacklisted"),
15495
- old: z32.boolean().nullable(),
15496
- new: z32.boolean().nullable()
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 = z32.object({
15555
+ var pinChange = z33.object({
15499
15556
  ...envelope,
15500
- kind: z32.literal("pinChange"),
15501
- type: z32.literal("blePin"),
15557
+ kind: z33.literal("pinChange"),
15558
+ type: z33.literal("blePin"),
15502
15559
  old: pin,
15503
15560
  new: pin
15504
15561
  });
15505
- var bikeChange = z32.object({
15562
+ var bikeChange = z33.object({
15506
15563
  ...envelope,
15507
- kind: z32.literal("bikeChange"),
15508
- type: z32.literal("bikeInfo"),
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 = z32.object({
15569
+ var membersChange = z33.object({
15513
15570
  ...envelope,
15514
- kind: z32.literal("membersChange"),
15515
- type: z32.enum(["users", "fleetUsers"]),
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 = z32.discriminatedUnion("kind", [...changes, unsupported]);
15529
- var operation = z32.object({
15585
+ var nestedChange = z33.discriminatedUnion("kind", [...changes, unsupported]);
15586
+ var operation = z33.object({
15530
15587
  type: text3,
15531
15588
  timestamp: time,
15532
- what: z32.discriminatedUnion("kind", [
15533
- z32.object({ kind: z32.literal("text"), value: z32.string() }),
15534
- z32.object({ kind: z32.literal("change"), value: nestedChange }),
15535
- z32.object({ kind: z32.literal("null") }),
15536
- z32.object({ kind: z32.literal("missing") }),
15537
- z32.object({ kind: z32.literal("invalid") })
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: z32.object({ id: text3, type: text3, fleetId: text3 }).nullable()
15596
+ doc: z33.object({ id: text3, type: text3, fleetId: text3 }).nullable()
15540
15597
  });
15541
- var diagnostic = z32.object({
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: z32.boolean().nullable(),
15610
+ outcomeUnknown: z33.boolean().nullable(),
15554
15611
  correlationId: text3
15555
15612
  });
15556
- var auditEvent = z32.discriminatedUnion("kind", [
15613
+ var auditEvent = z33.discriminatedUnion("kind", [
15557
15614
  ...changes,
15558
- z32.object({
15615
+ z33.object({
15559
15616
  ...envelope,
15560
- kind: z32.literal("message"),
15561
- type: z32.enum(["info", "error"]),
15617
+ kind: z33.literal("message"),
15618
+ type: z33.enum(["info", "error"]),
15562
15619
  message: text3,
15563
15620
  operationId: text3
15564
15621
  }),
15565
- z32.object({
15622
+ z33.object({
15566
15623
  ...envelope,
15567
- kind: z32.literal("note"),
15568
- type: z32.literal("blacklist"),
15624
+ kind: z33.literal("note"),
15625
+ type: z33.literal("blacklist"),
15569
15626
  note: text3
15570
15627
  }),
15571
- z32.object({
15628
+ z33.object({
15572
15629
  ...envelope,
15573
- kind: z32.literal("action"),
15574
- type: z32.enum(["clean", "factoryReset", "isBlacklisted"])
15630
+ kind: z33.literal("action"),
15631
+ type: z33.enum(["clean", "factoryReset", "isBlacklisted"])
15575
15632
  }),
15576
- z32.object({
15633
+ z33.object({
15577
15634
  ...envelope,
15578
- kind: z32.literal("failure"),
15579
- type: z32.literal("effectFailure"),
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
- z32.object({
15649
+ z33.object({
15593
15650
  ...envelope,
15594
- kind: z32.literal("operations"),
15595
- type: z32.enum(["read", "google.firestore.document.update"]),
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: z32.array(operation).nullable()
15659
+ operations: z33.array(operation).nullable()
15603
15660
  }),
15604
15661
  unsupported
15605
15662
  ]);
15606
- var auditEntry = z32.object({
15663
+ var auditEntry = z33.object({
15607
15664
  ...documentFields,
15608
15665
  event: auditEvent,
15609
- readIssues: z32.array(
15610
- z32.object({
15611
- path: z32.string(),
15612
- code: z32.enum(["unsupported_stored_event_type", "invalid_stored_value"])
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 = z32.object({
15617
- items: z32.array(auditEntry),
15673
+ var auditPage = z33.object({
15674
+ items: z33.array(auditEntry),
15618
15675
  nextAfter: historyCursor.nullable()
15619
15676
  });
15620
- var auditContract = oc21.meta({ operation: "read" }).errors(apiErrors).input(historyInput).output(auditPage);
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 oc22 } from "@orpc/contract";
15624
- import { z as z33 } from "zod";
15680
+ import { oc as oc23 } from "@orpc/contract";
15681
+ import { z as z34 } from "zod";
15625
15682
  var staffSubscription = subscription.extend({
15626
- email: z33.string().nullable(),
15627
- commerceId: z33.int().nullable(),
15628
- sku: z33.string().nullable()
15683
+ email: z34.string().nullable(),
15684
+ commerceId: z34.int().nullable(),
15685
+ sku: z34.string().nullable()
15629
15686
  });
15630
- var staffSubscriptionPageInput = z33.strictObject({
15687
+ var staffSubscriptionPageInput = z34.strictObject({
15631
15688
  ...pageFields,
15632
15689
  accountId: documentId.optional(),
15633
- commerceId: z33.int().positive().optional(),
15634
- businessEmail: z33.email().max(320).optional(),
15635
- businessOnly: z33.boolean().default(false)
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 = z33.object({
15638
- items: z33.array(staffSubscription),
15639
- nextAfter: z33.string().nullable()
15694
+ var staffSubscriptionPage = z34.object({
15695
+ items: z34.array(staffSubscription),
15696
+ nextAfter: z34.string().nullable()
15640
15697
  });
15641
15698
  var staffSubscriptionContract = {
15642
- get: oc22.meta({ operation: "read" }).errors(apiErrors).input(subscriptionInput).output(staffSubscription),
15643
- list: oc22.meta({ operation: "read" }).errors(apiErrors).input(staffSubscriptionPageInput).output(staffSubscriptionPage)
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 z34 } from "zod";
15648
- var exactValue = z34.string().min(1).max(128).refine(
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 = z34.discriminatedUnion("by", [
15653
- z34.strictObject({ by: z34.literal("serialNumber"), value: exactValue }),
15654
- z34.strictObject({ by: z34.literal("imei"), value: exactValue }),
15655
- z34.strictObject({ by: z34.literal("iccid"), value: exactValue }),
15656
- z34.strictObject({ by: z34.literal("accountId"), value: documentId }),
15657
- z34.strictObject({ by: z34.literal("subscriptionId"), value: documentId })
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 = z34.strictObject({
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 oc23 } from "@orpc/contract";
15666
- import { z as z36 } from "zod";
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 z35 } from "zod";
15670
- var providerId = z35.int().positive();
15726
+ import { z as z36 } from "zod";
15727
+ var providerId = z36.int().positive();
15671
15728
  var supportPageFields = {
15672
- page: z35.int().min(1).max(300).default(1),
15673
- limit: z35.int().min(1).max(100).default(20)
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 = z35.string().min(1).max(32).refine(
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 = z35.email().max(254).refine((value) => value.trim() === value);
15680
- var supportVersion = z35.string().regex(/^[a-f0-9]{64}$/);
15681
- var supportText = (max) => z35.string().min(1).max(max).refine((value) => value.trim().length > 0 && !value.includes("\0"));
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 = z36.object({
15747
+ var supportOperation = z37.object({
15691
15748
  requestId,
15692
- kind: z36.string().min(1),
15693
- status: z36.enum(["dispatching", "succeeded", "uncertain", "rejected"]),
15694
- resource: z36.string().min(1),
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: z36.string(),
15697
- createdAt: z36.iso.datetime(),
15698
- updatedAt: z36.iso.datetime()
15753
+ summary: z37.string(),
15754
+ createdAt: z37.iso.datetime(),
15755
+ updatedAt: z37.iso.datetime()
15699
15756
  });
15700
- var supportOperationInput = z36.strictObject({ requestId });
15757
+ var supportOperationInput = z37.strictObject({ requestId });
15701
15758
  var supportOperationContract = {
15702
- get: oc23.meta({ operation: "read" }).errors(supportErrors).input(supportOperationInput).output(supportOperation)
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 oc24 } from "@orpc/contract";
15707
- import { z as z37 } from "zod";
15708
- var moneyAmount = z37.string().regex(/^-?\d{1,12}(?:\.\d{1,6})?$/);
15709
- var commerceLine = z37.object({
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: z37.string(),
15712
- productId: z37.int().nonnegative(),
15713
- variationId: z37.int().nonnegative(),
15714
- quantity: z37.number(),
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: z37.string().nullable()
15776
+ sku: z38.string().nullable()
15720
15777
  });
15721
- var commerceOrder = z37.object({
15778
+ var commerceOrder = z38.object({
15722
15779
  id: providerId,
15723
- number: z37.string(),
15724
- status: z37.string(),
15780
+ number: z38.string(),
15781
+ status: z38.string(),
15725
15782
  billingEmail: supportEmail,
15726
- customerId: z37.int().nonnegative(),
15727
- currency: z37.string(),
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: z37.string(),
15733
- transactionId: z37.string().nullable(),
15734
- paidAtGmt: z37.string().nullable(),
15735
- modifiedAtGmt: z37.string(),
15736
- lines: z37.array(commerceLine),
15737
- refunds: z37.array(z37.object({ id: providerId, total: moneyAmount })),
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: z37.url().nullable()
15796
+ adminUrl: z38.url().nullable()
15740
15797
  });
15741
- var commerceSubscription = z37.object({
15798
+ var commerceSubscription = z38.object({
15742
15799
  id: providerId,
15743
- status: z37.string(),
15800
+ status: z38.string(),
15744
15801
  billingEmail: supportEmail,
15745
- customerId: z37.int().nonnegative(),
15746
- parentOrderId: z37.int().nonnegative(),
15747
- currency: z37.string(),
15802
+ customerId: z38.int().nonnegative(),
15803
+ parentOrderId: z38.int().nonnegative(),
15804
+ currency: z38.string(),
15748
15805
  total: moneyAmount,
15749
- paymentMethod: z37.string(),
15750
- manualRenewal: z37.boolean(),
15751
- billingPeriod: z37.string(),
15752
- billingInterval: z37.int().positive(),
15753
- nextPaymentAtGmt: z37.string().nullable(),
15754
- retryAtGmt: z37.string().nullable(),
15755
- endsAtGmt: z37.string().nullable(),
15756
- lines: z37.array(commerceLine),
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: z37.url().nullable()
15815
+ adminUrl: z38.url().nullable()
15759
15816
  });
15760
- var commerceNote = z37.object({
15817
+ var commerceNote = z38.object({
15761
15818
  id: providerId,
15762
- text: z37.string(),
15763
- author: z37.string().nullable(),
15764
- customerNote: z37.boolean(),
15765
- createdAtGmt: z37.string()
15819
+ text: z38.string(),
15820
+ author: z38.string().nullable(),
15821
+ customerNote: z38.boolean(),
15822
+ createdAtGmt: z38.string()
15766
15823
  });
15767
- var commerceRefund = z37.object({
15824
+ var commerceRefund = z38.object({
15768
15825
  id: providerId,
15769
15826
  amount: moneyAmount,
15770
- reason: z37.string(),
15771
- processorRefunded: z37.boolean()
15827
+ reason: z38.string(),
15828
+ processorRefunded: z38.boolean()
15772
15829
  });
15773
- var refundCapacity = z37.object({
15830
+ var refundCapacity = z38.object({
15774
15831
  orderId: providerId,
15775
- currency: z37.string(),
15832
+ currency: z38.string(),
15776
15833
  remainingAmount: moneyAmount,
15777
- priceDecimals: z37.int().min(0).max(6),
15778
- paymentMethod: z37.string(),
15779
- processorSupportsRefunds: z37.boolean(),
15780
- refundIds: z37.array(providerId),
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 = z37.object({
15840
+ var commerceRefundReview = z38.object({
15784
15841
  capacity: refundCapacity,
15785
- refunds: z37.array(commerceRefund)
15842
+ refunds: z38.array(commerceRefund)
15786
15843
  });
15787
- var commerceRelationships = z37.object({
15788
- resource: z37.enum(["order", "subscription"]),
15844
+ var commerceRelationships = z38.object({
15845
+ resource: z38.enum(["order", "subscription"]),
15789
15846
  id: providerId,
15790
- items: z37.array(
15791
- z37.object({ id: providerId, orderType: z37.string().nullable() })
15847
+ items: z38.array(
15848
+ z38.object({ id: providerId, orderType: z38.string().nullable() })
15792
15849
  )
15793
15850
  });
15794
- var commerceQuery = z37.strictObject({
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 = z37.strictObject({ id: providerId });
15859
+ var commerceId = z38.strictObject({ id: providerId });
15803
15860
  var commerceNotesInput = commerceId.extend(supportPageFields);
15804
- var page2 = (item) => z37.object({
15805
- items: z37.array(item),
15806
- nextPage: z37.int().positive().nullable(),
15807
- truncated: z37.boolean()
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 = oc24.meta({ operation: "read" }).errors(supportErrors).input(commerceId);
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: oc24.meta({ operation: "read" }).errors(supportErrors).input(commerceQuery).output(page2(commerceOrder)),
15814
- notes: oc24.meta({ operation: "read" }).errors(supportErrors).input(commerceNotesInput).output(page2(commerceNote)),
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: oc24.meta({ operation: "read" }).errors(supportErrors).input(commerceId.extend({ refundId: providerId })).output(commerceRefund)
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: oc24.meta({ operation: "read" }).errors(supportErrors).input(commerceQuery).output(page2(commerceSubscription)),
15822
- notes: oc24.meta({ operation: "read" }).errors(supportErrors).input(commerceNotesInput).output(page2(commerceNote)),
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 oc25 } from "@orpc/contract";
15829
- import { z as z38 } from "zod";
15830
- var billingReview = z38.strictObject({
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 = z38.strictObject({
15895
+ var reviewedResource = z39.strictObject({
15839
15896
  id: providerId,
15840
15897
  review: billingReview
15841
15898
  });
15842
15899
  var orderStatusChange = reviewedResource.extend({
15843
- status: z38.string().regex(/^[A-Za-z0-9_-]{1,100}$/).refine((value) => !value.startsWith("wc-"))
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: z38.enum(["endOfTerm", "immediate"])
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: z38.iso.datetime({ offset: true }).refine((value) => {
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: z38.string().min(1).max(12),
15916
+ currency: z39.string().min(1).max(12),
15860
15917
  reason: supportText(500)
15861
15918
  });
15862
15919
  var billingContract = {
15863
- orderStatus: oc25.errors(supportErrors).input(orderStatusChange).output(supportOperation),
15864
- subscriptionCancel: oc25.errors(supportErrors).input(subscriptionCancellation).output(supportOperation),
15865
- subscriptionCustomer: oc25.errors(supportErrors).input(subscriptionCustomerChange).output(supportOperation),
15866
- subscriptionPayment: oc25.errors(supportErrors).input(subscriptionPaymentChange).output(supportOperation),
15867
- refund: oc25.errors(supportErrors).input(orderRefund).output(supportOperation)
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 oc26 } from "@orpc/contract";
15872
- import { z as z39 } from "zod";
15873
- var supportPolicy = z39.object({
15874
- version: z39.literal(3),
15875
- markdown: z39.string().min(1),
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: z39.url()
15934
+ manualUrl: z40.url()
15878
15935
  });
15879
- var supportArticle = z39.object({
15936
+ var supportArticle = z40.object({
15880
15937
  id: providerId,
15881
- title: z39.string(),
15882
- text: z39.string(),
15883
- url: z39.url().nullable(),
15884
- modifiedAt: z39.iso.datetime()
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: oc26.meta({ operation: "read" }).errors(supportErrors).output(supportPolicy),
15893
- article: oc26.meta({ operation: "read" }).errors(supportErrors).input(z39.strictObject({ id: providerId })).output(supportArticle),
15894
- search: oc26.meta({ operation: "read" }).errors(supportErrors).input(z39.strictObject({ search: supportText(120) })).output(
15895
- z39.object({
15896
- items: z39.array(articleCandidate).max(5),
15897
- isExhaustive: z39.literal(false)
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 oc27 } from "@orpc/contract";
15904
- import { z as z40 } from "zod";
15905
- var loginEvent = z40.object({
15906
- id: z40.string().min(1),
15907
- type: z40.enum(["s", "f", "cs", "cls", "fepotpft"]),
15908
- description: z40.string().nullable(),
15909
- clientId: z40.string().nullable(),
15910
- accountId: z40.string().nullable(),
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: z40.iso.datetime()
15969
+ observedAt: z41.iso.datetime()
15913
15970
  });
15914
- var loginQuery = z40.strictObject({
15971
+ var loginQuery = z41.strictObject({
15915
15972
  email: supportEmail,
15916
- from: z40.iso.datetime(),
15917
- until: z40.iso.datetime(),
15918
- page: z40.int().min(1).max(50).default(1)
15919
- });
15920
- var loginContract = oc27.meta({ operation: "read" }).errors(supportErrors).input(loginQuery).output(
15921
- z40.object({
15922
- items: z40.array(loginEvent).max(20),
15923
- nextPage: z40.int().positive().nullable(),
15924
- truncated: z40.boolean()
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 oc28 } from "@orpc/contract";
15930
- import { z as z41 } from "zod";
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 = z41.object({
15991
+ var ticketAttachment = z42.object({
15935
15992
  id: providerId,
15936
- name: z41.string(),
15937
- contentType: z41.string(),
15938
- size: z41.int().nonnegative()
15993
+ name: z42.string(),
15994
+ contentType: z42.string(),
15995
+ size: z42.int().nonnegative()
15939
15996
  });
15940
- var ticketSummary = z41.object({
15997
+ var ticketSummary = z42.object({
15941
15998
  id: providerId,
15942
- subject: z41.string(),
15943
- status: z41.int().positive(),
15944
- priority: z41.int(),
15999
+ subject: z42.string(),
16000
+ status: z42.int().positive(),
16001
+ priority: z42.int(),
15945
16002
  requesterId: providerId,
15946
- groupId: z41.int().nullable(),
15947
- agentId: z41.int().nullable(),
15948
- tags: z41.array(z41.string()),
15949
- updatedAt: z41.iso.datetime()
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 = z41.object({
16008
+ var ticketMessage = z42.object({
15952
16009
  id: providerId,
15953
- agentId: z41.int().nullable(),
15954
- incoming: z41.boolean(),
15955
- private: z41.boolean(),
15956
- text: z41.string().nullable(),
15957
- createdAt: z41.iso.datetime(),
15958
- to: z41.array(z41.string()),
15959
- cc: z41.array(z41.string()),
15960
- bcc: z41.array(z41.string()),
15961
- attachments: z41.array(ticketAttachment)
15962
- });
15963
- var ticketContext = z41.object({
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: z41.string().nullable(),
15967
- attachments: z41.array(ticketAttachment),
15968
- messages: z41.array(ticketMessage),
15969
- version: z41.string().regex(/^[a-f0-9]{64}$/)
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 = z41.strictObject({ id: providerId });
15972
- var ticketQuery = z41.strictObject({
16028
+ var ticketInput = z42.strictObject({ id: providerId });
16029
+ var ticketQuery = z42.strictObject({
15973
16030
  ...supportPageFields,
15974
16031
  email: supportEmail.optional(),
15975
- updatedSince: z41.iso.datetime().optional(),
15976
- order: z41.enum(["newest", "oldest", "recentlyUpdated", "leastRecentlyUpdated"]).default("newest"),
15977
- statuses: z41.array(z41.int().positive()).max(20).optional(),
15978
- excludeTags: z41.array(supportTag).max(40).refine((tags) => new Set(tags).size === tags.length).optional(),
15979
- groupId: z41.int().nonnegative().optional(),
15980
- agentId: z41.int().nonnegative().optional()
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 = z41.object({
15983
- items: z41.array(ticketSummary),
15984
- nextPage: z41.int().positive().nullable(),
15985
- truncated: z41.boolean()
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 = z41.strictObject({
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: z41.array(supportTag).max(40),
15994
- remove: z41.array(supportTag).max(40)
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: oc28.meta({ operation: "read" }).errors(supportErrors).input(ticketInput.extend({ attachmentId: providerId })).output(ticketAttachmentDownload),
16001
- reply: oc28.errors(supportErrors).input(ticketReply).output(supportOperation),
16002
- close: oc28.errors(supportErrors).input(ticketClosure).output(supportOperation),
16003
- tags: oc28.errors(supportErrors).input(ticketTagChange).output(supportOperation),
16004
- list: oc28.meta({ operation: "read" }).errors(supportErrors).input(ticketQuery).output(ticketPage),
16005
- get: oc28.meta({ operation: "read" }).errors(supportErrors).input(ticketInput).output(ticketContext)
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 oc30 } from "@orpc/contract";
16010
- import { z as z42 } from "zod";
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 oc29 } from "@orpc/contract";
16070
+ import { oc as oc30 } from "@orpc/contract";
16014
16071
  var inventoryContract = {
16015
- resolve: oc29.meta({ operation: "read" }).errors(apiErrors).input(deviceLookupInput).output(deviceRegistration.strip())
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 = oc30.errors(apiErrors).input(trackerInput);
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: oc30.errors(apiErrors).input(trackerMemberAddInput).output(z42.void())
16106
+ add: oc31.errors(apiErrors).input(trackerMemberAddInput).output(z43.void())
16050
16107
  },
16051
- list: oc30.meta({ operation: "read" }).errors(apiErrors).input(staffTrackerPageInput).output(staffTrackerPage),
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,