@bikefinder/api-client 0.1.0 → 0.3.0

package/src/generated/zod.gen.ts

@@ -2,10 +2,166 @@
 
 import * as z from "zod";
 
+export const zAccountDeletionRequest = z.object({
+  requestId: z.string(),
+});
+
+export const zAccountNotification = z.object({
+  id: z.string(),
+  title: z.string(),
+  body: z.string(),
+  trackerId: z.string().nullable(),
+  timestampMs: z.int().gte(-9007199254740991).lte(9007199254740991),
+  subscriptionId: z.string().nullable(),
+});
+
+export const zBluetoothBatteryRequest = z.object({
+  seenAt: z.int().gte(-9007199254740991).lte(9007199254740991),
+  level: z
+    .int()
+    .min(-2147483648, {
+      error: "Invalid value: Expected int32 to be >= -2147483648",
+    })
+    .max(2147483647, {
+      error: "Invalid value: Expected int32 to be <= 2147483647",
+    })
+    .nullable(),
+  isCharging: z.boolean(),
+});
+
+export const zBluetoothCommandReport = z.object({
+  type: z.string(),
+  success: z.boolean(),
+});
+
+export const zBluetoothObservationBattery = z.object({
+  level: z.number().nullable(),
+  isCharging: z.boolean(),
+});
+
+export const zBluetoothObservationRequest = z.object({
+  requestId: z.string(),
+  type: z.string(),
+  timestampMs: z.int().gte(-9007199254740991).lte(9007199254740991),
+  latitude: z.number(),
+  longitude: z.number(),
+  accuracy: z.number(),
+  userLocationAccuracy: z.number(),
+  crowdKey: z
+    .int()
+    .min(-2147483648, {
+      error: "Invalid value: Expected int32 to be >= -2147483648",
+    })
+    .max(2147483647, {
+      error: "Invalid value: Expected int32 to be <= 2147483647",
+    })
+    .nullable(),
+  rssi: z
+    .int()
+    .min(-2147483648, {
+      error: "Invalid value: Expected int32 to be >= -2147483648",
+    })
+    .max(2147483647, {
+      error: "Invalid value: Expected int32 to be <= 2147483647",
+    })
+    .nullable(),
+  status: z.string(),
+  statusValue: z
+    .int()
+    .min(-2147483648, {
+      error: "Invalid value: Expected int32 to be >= -2147483648",
+    })
+    .max(2147483647, {
+      error: "Invalid value: Expected int32 to be <= 2147483647",
+    }),
+  bleId: z.string(),
+  appState: z.string(),
+  battery: zBluetoothObservationBattery,
+});
+
+export const zBluetoothObservationResult = z.object({
+  success: z.boolean(),
+  observationId: z.string(),
+});
+
+export const zBluetoothReportingPolicy = z.object({
+  pauseMs: z
+    .int()
+    .min(-2147483648, {
+      error: "Invalid value: Expected int32 to be >= -2147483648",
+    })
+    .max(2147483647, {
+      error: "Invalid value: Expected int32 to be <= 2147483647",
+    }),
+  accuracy: z
+    .int()
+    .min(-2147483648, {
+      error: "Invalid value: Expected int32 to be >= -2147483648",
+    })
+    .max(2147483647, {
+      error: "Invalid value: Expected int32 to be <= 2147483647",
+    }),
+});
+
+export const zClaimTrackerGuestAccessRequest = z.object({
+  accessCode: z.string(),
+  displayName: z.string().nullable(),
+});
+
+export const zClaimTrackerOwnershipRequest = z.object({
+  displayName: z.string().nullable(),
+});
+
+export const zCommandSuccess = z.object({
+  success: z.boolean(),
+});
+
+export const zCompleteFirmwareRequest = z.object({
+  from: z.string(),
+  version: z.string(),
+});
+
+export const zFactoryResetResult = z.object({
+  error: z.boolean(),
+});
+
 export const zHealthStatus = z.object({
   status: z.string(),
 });
 
+export const zIFormFile = z.string();
+
+export const zLegacyDevicePreferences = z.object({
+  unit: z.string(),
+  liquidGlass: z.boolean(),
+  mapStyle: z.string(),
+});
+
+export const zAccountPreferences = z.object({
+  language: z.string(),
+  alarm: z.boolean(),
+  timeSensitive: z.boolean(),
+  pushReady: z.boolean(),
+  devicePreferences: zLegacyDevicePreferences,
+});
+
+export const zNotificationPage = z.object({
+  items: z.array(zAccountNotification),
+  nextCursor: z.string().nullable(),
+});
+
+export const zPhotoUploadResult = z.object({
+  id: z.string(),
+});
+
+export const zPlanStatus = z.enum([
+  "active",
+  "ending",
+  "hold",
+  "inactive",
+  "unknown",
+]);
+
 export const zProblemDetails = z.object({
   type: z.string().nullish(),
   title: z.string().nullish(),
@@ -22,13 +178,287 @@ export const zProblemDetails = z.object({
   instance: z.string().nullish(),
 });
 
+export const zRecordFirmwareAttemptRequest = z.object({
+  attemptId: z.string(),
+  success: z.boolean(),
+});
+
+export const zRecordFirmwareAttemptResult = z.object({
+  success: z.boolean(),
+  recorded: z.boolean(),
+});
+
+export const zRegisterPushRegistrationRequest = z.object({
+  token: z.string(),
+  previousTokens: z.array(z.string()).nullish(),
+  platform: z.string().nullish(),
+});
+
+export const zRemovePushRegistrationRequest = z.object({
+  tokens: z.array(z.string()),
+});
+
+export const zRemoveTrackerMembershipRequest = z.object({
+  expectedLastMember: z.boolean(),
+});
+
+export const zSubmitTrackerTheftReportRequest = z.object({
+  requestId: z.string(),
+  phoneNumber: z.string(),
+});
+
+export const zSubscriptionChangeRequest = z.object({
+  subscriptionId: z.string(),
+});
+
+export const zSubscriptionPlan = z.object({
+  id: z.string(),
+  ownerUid: z.string().nullable(),
+  name: z.string(),
+  fallbackTier: z
+    .int()
+    .min(-2147483648, {
+      error: "Invalid value: Expected int32 to be >= -2147483648",
+    })
+    .max(2147483647, {
+      error: "Invalid value: Expected int32 to be <= 2147483647",
+    })
+    .nullable(),
+  status: zPlanStatus,
+  isActive: z.boolean().nullable(),
+  quantity: z
+    .int()
+    .min(-2147483648, {
+      error: "Invalid value: Expected int32 to be >= -2147483648",
+    })
+    .max(2147483647, {
+      error: "Invalid value: Expected int32 to be <= 2147483647",
+    })
+    .nullable(),
+  available: z
+    .int()
+    .min(-2147483648, {
+      error: "Invalid value: Expected int32 to be >= -2147483648",
+    })
+    .max(2147483647, {
+      error: "Invalid value: Expected int32 to be <= 2147483647",
+    }),
+  trackerIds: z.array(z.string()),
+  managementUrl: z.string().nullable(),
+  nextRenewalMs: z
+    .int()
+    .gte(-9007199254740991)
+    .lte(9007199254740991)
+    .nullable(),
+  endMs: z.int().gte(-9007199254740991).lte(9007199254740991).nullable(),
+});
+
+export const zSubscriptionList = z.object({
+  items: z.array(zSubscriptionPlan),
+});
+
+export const zTrackerBattery = z.object({
+  level: z
+    .int()
+    .min(-2147483648, {
+      error: "Invalid value: Expected int32 to be >= -2147483648",
+    })
+    .max(2147483647, {
+      error: "Invalid value: Expected int32 to be <= 2147483647",
+    })
+    .nullable(),
+  isCharging: z.boolean(),
+  timestampMs: z.int().gte(-9007199254740991).lte(9007199254740991).nullable(),
+});
+
+export const zTrackerBikeDetails = z.object({
+  nickname: z.string(),
+  brand: z.string(),
+  type: z.string(),
+  model: z.string(),
+  frameNumber: z.string(),
+  marketPrice: z.string(),
+  marketPriceCurrency: z.string(),
+  url: z.string(),
+});
+
+export const zTrackerBluetoothCredentials = z.object({
+  id: z.string(),
+  imei: z.string().nullable(),
+  generation: z
+    .int()
+    .min(-2147483648, {
+      error: "Invalid value: Expected int32 to be >= -2147483648",
+    })
+    .max(2147483647, {
+      error: "Invalid value: Expected int32 to be <= 2147483647",
+    })
+    .nullable(),
+  pin: z.array(
+    z
+      .int()
+      .min(-2147483648, {
+        error: "Invalid value: Expected int32 to be >= -2147483648",
+      })
+      .max(2147483647, {
+        error: "Invalid value: Expected int32 to be <= 2147483647",
+      }),
+  ),
+  rotatePin: z.boolean(),
+});
+
+export const zTrackerClaimabilityRequest = z.object({
+  deviceIds: z.array(z.string()),
+});
+
+export const zTrackerFirmwarePlan = z.object({
+  trackerId: z.string(),
+  from: z.string(),
+  version: z.string(),
+  url: z.string(),
+  blockSize: z
+    .int()
+    .min(-2147483648, {
+      error: "Invalid value: Expected int32 to be >= -2147483648",
+    })
+    .max(2147483647, {
+      error: "Invalid value: Expected int32 to be <= 2147483647",
+    }),
+  requiredBattery: z
+    .int()
+    .min(-2147483648, {
+      error: "Invalid value: Expected int32 to be >= -2147483648",
+    })
+    .max(2147483647, {
+      error: "Invalid value: Expected int32 to be <= 2147483647",
+    }),
+  blockTimeoutMs: z
+    .int()
+    .min(-2147483648, {
+      error: "Invalid value: Expected int32 to be >= -2147483648",
+    })
+    .max(2147483647, {
+      error: "Invalid value: Expected int32 to be <= 2147483647",
+    }),
+  rebootTimeoutMs: z
+    .int()
+    .min(-2147483648, {
+      error: "Invalid value: Expected int32 to be >= -2147483648",
+    })
+    .max(2147483647, {
+      error: "Invalid value: Expected int32 to be <= 2147483647",
+    }),
+});
+
+export const zTrackerFirmwareVersions = z.object({
+  lte: z.string().nullable(),
+  ble: z.string().nullable(),
+  bat: z.string().nullable(),
+  tiFirmware: z.string().nullable(),
+  mtkFirmware: z.string().nullable(),
+});
+
+export const zTrackerInvitation = z.object({
+  accessCode: z.string(),
+});
+
+export const zTrackerModeResult = z.object({
+  success: z.boolean(),
+  requestedMode: z.string(),
+});
+
+export const zTrackerPhoto = z.object({
+  id: z.string(),
+  kind: z.string(),
+  url: z.string(),
+  thumbnailUrl: z.string(),
+  timestampMs: z.int().gte(-9007199254740991).lte(9007199254740991).nullable(),
+});
+
+export const zTrackerPhotoList = z.object({
+  items: z.array(zTrackerPhoto),
+});
+
+export const zTrackerPosition = z.object({
+  id: z.string(),
+  latitude: z.number(),
+  longitude: z.number(),
+  timestampMs: z.int().gte(-9007199254740991).lte(9007199254740991),
+  source: z.string(),
+  accuracy: z.number().nullable(),
+});
+
+export const zHistoryPage = z.object({
+  items: z.array(zTrackerPosition),
+  nextCursor: z.string().nullable(),
+});
+
+export const zTrackerPositionState = z.object({
+  latest: zTrackerPosition.nullable(),
+  lastPrecise: zTrackerPosition.nullable(),
+});
+
+export const zTrackerSubscription = z.object({
+  id: z.string().nullable(),
+  status: z.string(),
+  endTimestampMs: z
+    .int()
+    .gte(-9007199254740991)
+    .lte(9007199254740991)
+    .nullable(),
+  tier: z
+    .int()
+    .min(-2147483648, {
+      error: "Invalid value: Expected int32 to be >= -2147483648",
+    })
+    .max(2147483647, {
+      error: "Invalid value: Expected int32 to be <= 2147483647",
+    })
+    .nullable(),
+});
+
+export const zTrackerTheftReportResult = z.object({
+  success: z.boolean(),
+  reportId: z.string(),
+  requestId: z.string(),
+});
+
 export const zTrackingMode = z.enum(["standard", "security", "tracking"]);
 
+export const zTrackerModeRequest = z.object({
+  mode: zTrackingMode,
+});
+
 export const zTrackerSummary = z.object({
   id: z.string(),
   nickname: z.string().nullable(),
   requestedMode: zTrackingMode.nullable(),
   subscriptionActive: z.boolean().nullable(),
+  bikeDetails: zTrackerBikeDetails.nullable(),
+  battery: zTrackerBattery.nullable(),
+  subscription: zTrackerSubscription.nullable(),
+  membershipCount: z
+    .int()
+    .min(-2147483648, {
+      error: "Invalid value: Expected int32 to be >= -2147483648",
+    })
+    .max(2147483647, {
+      error: "Invalid value: Expected int32 to be <= 2147483647",
+    }),
+  sharingCodes: z.array(z.string()).nullable(),
+  generation: z
+    .int()
+    .min(-2147483648, {
+      error: "Invalid value: Expected int32 to be >= -2147483648",
+    })
+    .max(2147483647, {
+      error: "Invalid value: Expected int32 to be <= 2147483647",
+    })
+    .nullable(),
+  imei: z.string().nullable(),
+  iccid: z.string().nullable(),
+  firmwareVersions: zTrackerFirmwareVersions.nullable(),
+  lastCommunicationMode: z.string().nullable(),
 });
 
 export const zTrackerPage = z.object({
@@ -36,42 +466,82 @@ export const zTrackerPage = z.object({
   nextCursor: z.string().nullable(),
 });
 
+export const zUpdateAccountPreferencesRequest = z.object({
+  language: z.string().nullish(),
+  alarm: z.boolean().nullish(),
+  timeSensitive: z.boolean().nullish(),
+});
+
+export const zUpdateBluetoothPinRequest = z.object({
+  pin: z.array(
+    z
+      .int()
+      .min(-2147483648, {
+        error: "Invalid value: Expected int32 to be >= -2147483648",
+      })
+      .max(2147483647, {
+        error: "Invalid value: Expected int32 to be <= 2147483647",
+      }),
+  ),
+  expected: z.array(
+    z
+      .int()
+      .min(-2147483648, {
+        error: "Invalid value: Expected int32 to be >= -2147483648",
+      })
+      .max(2147483647, {
+        error: "Invalid value: Expected int32 to be <= 2147483647",
+      }),
+  ),
+  clearRotation: z.boolean(),
+});
+
+export const zUpdateTrackerBikeRequest = z.object({
+  before: zTrackerBikeDetails,
+  draft: zTrackerBikeDetails,
+});
+
 /**
  * OK
  */
 export const zGetHealthResponse = zHealthStatus;
 
-export const zListTrackersQuery = z.object({
-  cursor: z
+/**
+ * OK
+ */
+export const zGetBluetoothReportingPolicyResponse = zBluetoothReportingPolicy;
+
+export const zUnlinkTrackerSubscriptionBody = zSubscriptionChangeRequest;
+
+export const zUnlinkTrackerSubscriptionPath = z.object({
+  trackerId: z
     .string()
     .min(1)
     .max(128)
-    .regex(/^[A-Za-z0-9_-]+$/)
-    .optional(),
-  limit: z.int().gte(1).lte(100).optional().default(50),
+    .regex(/^[A-Za-z0-9_-]+$/),
 });
 
 /**
  * OK
  */
-export const zListTrackersResponse = zTrackerPage;
+export const zUnlinkTrackerSubscriptionResponse = zCommandSuccess;
 
-export const zSubscribeTrackersQuery = z.object({
-  cursor: z
+export const zLinkTrackerSubscriptionBody = zSubscriptionChangeRequest;
+
+export const zLinkTrackerSubscriptionPath = z.object({
+  trackerId: z
     .string()
     .min(1)
     .max(128)
-    .regex(/^[A-Za-z0-9_-]+$/)
-    .optional(),
-  limit: z.int().gte(1).lte(100).optional().default(50),
+    .regex(/^[A-Za-z0-9_-]+$/),
 });
 
 /**
  * OK
  */
-export const zSubscribeTrackersResponse = zTrackerPage.nullable();
+export const zLinkTrackerSubscriptionResponse = zCommandSuccess;
 
-export const zGetTrackerPath = z.object({
+export const zListTrackerPhotosPath = z.object({
   trackerId: z
     .string()
     .min(1)
@@ -82,4 +552,488 @@ export const zGetTrackerPath = z.object({
 /**
  * OK
  */
-export const zGetTrackerResponse = zTrackerSummary;
+export const zListTrackerPhotosResponse = zTrackerPhotoList;
+
+export const zUploadTrackerPhotoBody = z
+  .object({
+    file: zIFormFile,
+  })
+  .and(
+    z.object({
+      kind: z.string(),
+    }),
+  )
+  .and(
+    z.object({
+      width: z
+        .int()
+        .min(-2147483648, {
+          error: "Invalid value: Expected int32 to be >= -2147483648",
+        })
+        .max(2147483647, {
+          error: "Invalid value: Expected int32 to be <= 2147483647",
+        }),
+    }),
+  )
+  .and(
+    z.object({
+      height: z
+        .int()
+        .min(-2147483648, {
+          error: "Invalid value: Expected int32 to be >= -2147483648",
+        })
+        .max(2147483647, {
+          error: "Invalid value: Expected int32 to be <= 2147483647",
+        }),
+    }),
+  );
+
+export const zUploadTrackerPhotoPath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+});
+
+/**
+ * OK
+ */
+export const zUploadTrackerPhotoResponse = zPhotoUploadResult;
+
+export const zDeleteTrackerPhotoPath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+  photoId: z.string(),
+});
+
+/**
+ * OK
+ */
+export const zDeleteTrackerPhotoResponse = zCommandSuccess;
+
+export const zListTrackersQuery = z.object({
+  cursor: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/)
+    .optional(),
+  limit: z.int().gte(1).lte(100).optional().default(50),
+});
+
+/**
+ * OK
+ */
+export const zListTrackersResponse = zTrackerPage;
+
+export const zSubscribeTrackersQuery = z.object({
+  cursor: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/)
+    .optional(),
+  limit: z.int().gte(1).lte(100).optional().default(50),
+});
+
+/**
+ * OK
+ */
+export const zSubscribeTrackersResponse = zTrackerPage.nullable();
+
+export const zGetTrackerPath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+});
+
+/**
+ * OK
+ */
+export const zGetTrackerResponse = zTrackerSummary;
+
+export const zGetTrackerPositionsPath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+});
+
+/**
+ * OK
+ */
+export const zGetTrackerPositionsResponse = zTrackerPositionState;
+
+export const zSubscribeTrackerPositionsPath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+});
+
+/**
+ * OK
+ */
+export const zSubscribeTrackerPositionsResponse =
+  zTrackerPositionState.nullable();
+
+export const zSubscribeTrackerPhotosPath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+});
+
+/**
+ * OK
+ */
+export const zSubscribeTrackerPhotosResponse = zTrackerPhotoList.nullable();
+
+export const zRequestTrackerModeBody = zTrackerModeRequest;
+
+export const zRequestTrackerModePath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+});
+
+/**
+ * OK
+ */
+export const zRequestTrackerModeResponse = zTrackerModeResult;
+
+export const zCheckTrackerClaimabilityBody = zTrackerClaimabilityRequest;
+
+/**
+ * OK
+ */
+export const zCheckTrackerClaimabilityResponse = z.record(
+  z.string(),
+  z.boolean(),
+);
+
+export const zClaimTrackerOwnershipBody = zClaimTrackerOwnershipRequest;
+
+export const zClaimTrackerOwnershipPath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+});
+
+/**
+ * OK
+ */
+export const zClaimTrackerOwnershipResponse = zCommandSuccess;
+
+export const zClaimTrackerGuestAccessBody = zClaimTrackerGuestAccessRequest;
+
+export const zClaimTrackerGuestAccessPath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+});
+
+/**
+ * OK
+ */
+export const zClaimTrackerGuestAccessResponse = zCommandSuccess;
+
+export const zCreateTrackerInvitationPath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+});
+
+/**
+ * OK
+ */
+export const zCreateTrackerInvitationResponse = zTrackerInvitation;
+
+export const zRevokeTrackerInvitationPath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+  accessCode: z.string(),
+});
+
+/**
+ * OK
+ */
+export const zRevokeTrackerInvitationResponse = zCommandSuccess;
+
+export const zRemoveTrackerMembershipBody = zRemoveTrackerMembershipRequest;
+
+export const zRemoveTrackerMembershipPath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+});
+
+/**
+ * OK
+ */
+export const zRemoveTrackerMembershipResponse = zCommandSuccess;
+
+export const zUpdateTrackerBikeBody = zUpdateTrackerBikeRequest;
+
+export const zUpdateTrackerBikePath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+});
+
+/**
+ * OK
+ */
+export const zUpdateTrackerBikeResponse = zTrackerBikeDetails;
+
+export const zSubmitTrackerTheftReportBody = zSubmitTrackerTheftReportRequest;
+
+export const zSubmitTrackerTheftReportPath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+});
+
+/**
+ * OK
+ */
+export const zSubmitTrackerTheftReportResponse = zTrackerTheftReportResult;
+
+export const zGetTrackerBluetoothCredentialsPath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+});
+
+/**
+ * OK
+ */
+export const zGetTrackerBluetoothCredentialsResponse =
+  zTrackerBluetoothCredentials;
+
+export const zUpdateTrackerBluetoothPinBody = zUpdateBluetoothPinRequest;
+
+export const zUpdateTrackerBluetoothPinPath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+});
+
+/**
+ * OK
+ */
+export const zUpdateTrackerBluetoothPinResponse = zCommandSuccess;
+
+export const zReportTrackerBluetoothBatteryBody = zBluetoothBatteryRequest;
+
+export const zReportTrackerBluetoothBatteryPath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+});
+
+/**
+ * OK
+ */
+export const zReportTrackerBluetoothBatteryResponse = zCommandSuccess;
+
+export const zReportTrackerBluetoothCommandBody = zBluetoothCommandReport;
+
+export const zReportTrackerBluetoothCommandPath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+});
+
+/**
+ * OK
+ */
+export const zReportTrackerBluetoothCommandResponse = zCommandSuccess;
+
+export const zUploadTrackerBluetoothObservationBody =
+  zBluetoothObservationRequest;
+
+export const zUploadTrackerBluetoothObservationPath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+});
+
+/**
+ * OK
+ */
+export const zUploadTrackerBluetoothObservationResponse =
+  zBluetoothObservationResult;
+
+export const zReportTrackerFactoryResetPath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+});
+
+/**
+ * OK
+ */
+export const zReportTrackerFactoryResetResponse = zFactoryResetResult;
+
+export const zGetTrackerFirmwarePlanPath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+});
+
+export const zGetTrackerFirmwarePlanQuery = z.object({
+  platform: z.string(),
+  build: z.string(),
+});
+
+/**
+ * OK
+ */
+export const zGetTrackerFirmwarePlanResponse = zTrackerFirmwarePlan;
+
+export const zCompleteTrackerFirmwareUpdateBody = zCompleteFirmwareRequest;
+
+export const zCompleteTrackerFirmwareUpdatePath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+});
+
+/**
+ * OK
+ */
+export const zCompleteTrackerFirmwareUpdateResponse = zCommandSuccess;
+
+export const zRecordTrackerFirmwareAttemptBody = zRecordFirmwareAttemptRequest;
+
+export const zRecordTrackerFirmwareAttemptPath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+});
+
+/**
+ * OK
+ */
+export const zRecordTrackerFirmwareAttemptResponse =
+  zRecordFirmwareAttemptResult;
+
+/**
+ * OK
+ */
+export const zGetAccountPreferencesResponse = zAccountPreferences;
+
+export const zUpdateAccountPreferencesBody = zUpdateAccountPreferencesRequest;
+
+/**
+ * OK
+ */
+export const zUpdateAccountPreferencesResponse = zAccountPreferences;
+
+/**
+ * OK
+ */
+export const zSubscribeAccountPreferencesResponse =
+  zAccountPreferences.nullable();
+
+export const zRemovePushRegistrationBody = zRemovePushRegistrationRequest;
+
+/**
+ * No Content
+ */
+export const zRemovePushRegistrationResponse = z.void();
+
+export const zRegisterPushRegistrationBody = zRegisterPushRegistrationRequest;
+
+/**
+ * No Content
+ */
+export const zRegisterPushRegistrationResponse = z.void();
+
+/**
+ * Accepted
+ */
+export const zRequestAccountDeletionResponse = zAccountDeletionRequest;
+
+export const zListTrackerHistoryPath = z.object({
+  trackerId: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/),
+});
+
+export const zListTrackerHistoryQuery = z.object({
+  startMs: z.int().gte(-9007199254740991).lte(9007199254740991),
+  endMs: z.int().gte(-9007199254740991).lte(9007199254740991),
+  cursor: z.string().optional(),
+});
+
+/**
+ * OK
+ */
+export const zListTrackerHistoryResponse = zHistoryPage;
+
+export const zListNotificationsQuery = z.object({
+  cursor: z.string().optional(),
+});
+
+/**
+ * OK
+ */
+export const zListNotificationsResponse = zNotificationPage;
+
+/**
+ * OK
+ */
+export const zListSubscriptionsResponse = zSubscriptionList;
+
+/**
+ * OK
+ */
+export const zSubscribeSubscriptionsResponse = zSubscriptionList.nullable();