@seamapi/types 0.17.0 → 0.19.0

package/src/lib/seam/connect/unstable/model-types.ts

@@ -1,8 +1,12 @@
 export type {
+  AccessCodeConstraint,
   AnyDeviceType,
+  BatteryStatus,
   Capabilities,
+  ClimateSetting,
   LockDeviceType,
   ManagedDevice,
+  ManagedDeviceWithBackendMetadata,
   NoiseSensorDeviceType,
   ThermostatDeviceType,
   UnmanagedDevice,

package/src/lib/seam/connect/unstable/models/capability-properties/access-code.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod'
+
+const simple_access_code_constraint = z.object({
+  constraint_type: z.enum([
+    'no_zeros', // Nuki
+    'cannot_start_with_12', // Nuki
+    'no_triple_consecutive_ints', // Brivo
+    'cannot_specify_pin_code', // Lockly
+    'pin_code_matches_existing_set', // Salto
+    'start_date_in_future', // Kwikset
+  ]),
+})
+
+const complex_access_code_constraint = z.object({
+  constraint_type: z.enum(['name_length']), // Nuki, Kwikset
+  min_length: z.number().optional(),
+  max_length: z.number().optional(),
+})
+
+export const access_code_constraint = z.union([
+  simple_access_code_constraint,
+  complex_access_code_constraint,
+])
+
+export type AccessCodeConstraint = z.infer<typeof access_code_constraint>
+
+export const access_code_capability_properties = z.object({
+  code_constraints: z.array(access_code_constraint).optional(),
+  supported_code_lengths: z.array(z.number()).optional(),
+  max_active_codes_supported: z.number().optional(),
+  supports_backup_access_code_pool: z.boolean().optional(),
+  has_native_entry_events: z.boolean().optional(),
+})

package/src/lib/seam/connect/unstable/models/capability-properties/index.ts

@@ -0,0 +1,26 @@
+import { access_code_capability_properties } from './access-code.js'
+import { lock_capability_properties } from './lock.js'
+import {
+  climate_setting,
+  climate_setting_schedule,
+  hvac_mode_setting,
+  thermostat_capability_properties,
+} from './thermostat.js'
+
+export {
+  access_code_capability_properties,
+  climate_setting,
+  climate_setting_schedule,
+  hvac_mode_setting,
+  lock_capability_properties,
+  thermostat_capability_properties,
+}
+
+// todo: discriminate based on capability and remove intersection type
+export const capability_properties = access_code_capability_properties
+  .partial()
+  .merge(lock_capability_properties.partial())
+  .merge(thermostat_capability_properties.partial())
+
+export type { AccessCodeConstraint } from './access-code.js'
+export type { ClimateSetting } from './thermostat.js'

package/src/lib/seam/connect/unstable/models/capability-properties/lock.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod'
+
+export const lock_capability_properties = z.object({
+  locked: z.boolean().optional(),
+  keypad_battery: z
+    .object({
+      level: z.number(),
+    })
+    .optional(),
+  door_open: z.boolean().optional(),
+})

package/src/lib/seam/connect/unstable/models/capability-properties/thermostat.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod'
+
+export const climate_setting = z.object({
+  automatic_heating_enabled: z.boolean(),
+  automatic_cooling_enabled: z.boolean(),
+  hvac_mode_setting: z.enum(['off', 'heat', 'cool', 'heatcool']),
+  cooling_set_point_celsius: z.number().optional(),
+  heating_set_point_celsius: z.number().optional(),
+  cooling_set_point_fahrenheit: z.number().optional(),
+  heating_set_point_fahrenheit: z.number().optional(),
+  manual_override_allowed: z.boolean(),
+})
+
+export type ClimateSetting = z.infer<typeof climate_setting>
+
+export const climate_setting_schedule = z
+  .object({
+    climate_setting_schedule_id: z.string().uuid(),
+    schedule_type: z.literal('time_bound'),
+    device_id: z.string(),
+    name: z.string().optional(),
+    schedule_starts_at: z.string(),
+    schedule_ends_at: z.string(),
+    created_at: z.string().datetime(),
+  })
+  .merge(climate_setting.partial())
+
+export const hvac_mode_setting = z.enum(['off', 'heat', 'cool', 'heatcool'])
+
+export const thermostat_capability_properties = z.object({
+  temperature_fahrenheit: z.number(),
+  temperature_celsius: z.number(),
+  relative_humidity: z.number().min(0).max(1),
+  can_enable_automatic_heating: z.boolean(),
+  can_enable_automatic_cooling: z.boolean(),
+  available_hvac_mode_settings: z.array(hvac_mode_setting),
+  is_heating: z.boolean(),
+  is_cooling: z.boolean(),
+  is_fan_running: z.boolean(),
+
+  /**
+   * this is true if the current thermostat settings differ that what is on seam, and `current_climate_setting.manual_override_allowed: true`
+   */
+  is_temporary_manual_override_active: z.boolean(),
+
+  /**
+   * can be derived from `default_climate_setting`, or `active_climate_setting_schedule` if one is active
+   */
+  current_climate_setting: climate_setting,
+  default_climate_setting: climate_setting.optional(),
+  is_climate_setting_schedule_active: z.boolean(),
+  active_climate_setting_schedule: climate_setting_schedule.optional(),
+})

package/src/lib/seam/connect/unstable/models/device-metadata.ts

@@ -0,0 +1,162 @@
+import { z } from 'zod'
+
+export const device_metadata = z
+  .object({
+    august_metadata: z.object({
+      lock_id: z.string(),
+      lock_name: z.string(),
+      house_name: z.string(),
+      has_keypad: z.boolean(),
+      keypad_battery_level: z.string().optional(),
+      model: z.string().optional(),
+      house_id: z.string().optional(),
+    }),
+
+    schlage_metadata: z.object({
+      device_id: z.string(),
+      device_name: z.string(),
+      access_code_length: z.number(),
+      model: z.string().optional(),
+    }),
+
+    smartthings_metadata: z.object({
+      device_id: z.string(),
+      device_name: z.string(),
+      model: z.string().optional(),
+      location_id: z.string().optional(),
+    }),
+
+    lockly_metadata: z.object({
+      device_id: z.string(),
+      device_name: z.string(),
+      model: z.string().optional(),
+    }),
+
+    nuki_metadata: z.object({
+      device_id: z.string(),
+      device_name: z.string(),
+      keypad_battery_critical: z.boolean().optional(),
+    }),
+
+    kwikset_metadata: z.object({
+      device_id: z.string(),
+      device_name: z.string(),
+      model_number: z.string(),
+    }),
+
+    salto_metadata: z.object({
+      lock_id: z.string(),
+      customer_reference: z.string(),
+      lock_type: z.string(),
+      battery_level: z.string(),
+      locked_state: z.string(),
+      model: z.string().optional(),
+    }),
+
+    genie_metadata: z.object({
+      device_name: z.string(),
+      door_name: z.string(),
+    }),
+
+    brivo_metadata: z.object({
+      device_name: z.string(),
+    }),
+
+    igloo_metadata: z.object({
+      device_id: z.string(),
+      bridge_id: z.string(),
+      model: z.string().optional(),
+    }),
+
+    noiseaware_metadata: z.object({
+      device_model: z.enum(['indoor', 'outdoor']),
+      noise_level_nrs: z.number(),
+      noise_level_decibel: z.number(),
+      device_name: z.string(),
+      device_id: z.string(),
+    }),
+
+    minut_metadata: z.object({
+      device_id: z.string(),
+      device_name: z.string(),
+      latest_sensor_values: z.object({
+        temperature: z.object({
+          time: z.string(),
+          value: z.number(),
+        }),
+        sound: z.object({
+          time: z.string(),
+          value: z.number(),
+        }),
+        humidity: z.object({
+          time: z.string(),
+          value: z.number(),
+        }),
+        pressure: z.object({
+          time: z.string(),
+          value: z.number(),
+        }),
+        accelerometer_z: z.object({
+          time: z.string(),
+          value: z.number(),
+        }),
+      }),
+    }),
+
+    two_n_metadata: z.object({
+      device_id: z.number(),
+      device_name: z.string(),
+    }),
+
+    controlbyweb_metadata: z.object({
+      device_id: z.string(),
+      device_name: z.string(),
+      relay_name: z.string().nullable(),
+    }),
+
+    ttlock_metadata: z.object({
+      lock_id: z.number(),
+      lock_alias: z.string(),
+    }),
+
+    seam_bridge_metadata: z.object({
+      unlock_method: z.enum(['bridge', 'doorking']).optional(),
+      device_num: z.number(),
+      name: z.string(),
+    }),
+
+    igloohome_metadata: z.object({
+      device_id: z.string(),
+      bridge_id: z.string(),
+      device_name: z.string(),
+      bridge_name: z.string(),
+    }),
+
+    nest_metadata: z.object({
+      nest_device_id: z.string(),
+      device_name: z.string(), // set by Google
+      custom_name: z.string(), // set by device owner
+    }),
+
+    ecobee_metadata: z.object({
+      ecobee_device_id: z.string(),
+      device_name: z.string(),
+      min_heating_set_point_fahrenheit: z.number().optional(),
+      max_heating_set_point_fahrenheit: z.number().optional(),
+      min_cooling_set_point_fahrenheit: z.number().optional(),
+      max_cooling_set_point_fahrenheit: z.number().optional(),
+      min_heating_set_point_celsius: z.number().optional(),
+      max_heating_set_point_celsius: z.number().optional(),
+      min_cooling_set_point_celsius: z.number().optional(),
+      max_cooling_set_point_celsius: z.number().optional(),
+      min_delta_heat_cool_set_points_fahrenheit: z.number().optional(),
+      min_delta_heat_cool_set_points_celsius: z.number().optional(),
+    }),
+
+    hubitat_metadata: z.object({
+      device_id: z.string(),
+      device_name: z.string(),
+      device_label: z.string(),
+    }),
+  })
+  .partial()

package/src/lib/seam/connect/unstable/models/index.ts

@@ -1,4 +1,5 @@
 export * from './capabilities-supported.js'
+export * from './capability-properties/index.js'
 export * from './device-type.js'
 export * from './managed-device.js'
 export * from './unmanaged-device.js'

package/src/lib/seam/connect/unstable/models/managed-device.ts

@@ -1,23 +1,50 @@
+import type { SetRequired, Simplify } from 'type-fest'
 import { z } from 'zod'
 
 import { capabilities } from './capabilities-supported.js'
+import { capability_properties } from './capability-properties/index.js'
+import { device_metadata } from './device-metadata.js'
 import { any_device_type } from './device-type.js'
 
+export const battery_status = z.enum(['critical', 'low', 'good', 'full'])
+
+export type BatteryStatus = z.infer<typeof battery_status>
+
+export const common_device_properties = z.object({
+  online: z.boolean(),
+  name: z.string(),
+  model: z.object({
+    display_name: z.string(),
+  }),
+  has_direct_power: z.boolean().optional(),
+  battery_level: z.number().min(0).max(1).optional(),
+  battery: z
+    .object({
+      level: z.number().min(0).max(1),
+      status: battery_status,
+    })
+    .optional(),
+  // todo: use enum
+  manufacturer: z.string().optional(),
+  image_url: z.string().url().optional(),
+  image_alt_text: z.string().optional(),
+  serial_number: z.string().optional(),
+})
+
 export const managed_device = z.object({
   device_id: z.string().uuid(),
   device_type: any_device_type,
   capabilities_supported: z.array(capabilities),
-  properties: z
+  properties: common_device_properties
+    .and(device_metadata)
+    .and(capability_properties),
+  location: z
+    // todo: optional instead of nullable
     .object({
-      online: z.boolean(),
-      name: z.string(),
-      model: z.object({
-        display_name: z.string(),
-      }),
+      location_name: z.string().optional(),
+      timezone: z.string().optional(),
     })
-    .and(z.record(z.string(), z.any())),
-  // todo: better type
-  location: z.any(),
+    .nullable(),
   connected_account_id: z.string().uuid(),
   workspace_id: z.string().uuid(),
   errors: z.array(
@@ -37,3 +64,11 @@ export const managed_device = z.object({
 })
 
 export type ManagedDevice = z.infer<typeof managed_device>
+
+export type ManagedDeviceWithBackendMetadata<
+  MetadataKey extends keyof z.infer<typeof device_metadata>,
+> = Simplify<
+  ManagedDevice & {
+    properties: SetRequired<ManagedDevice['properties'], MetadataKey>
+  }
+>

package/src/lib/seam/connect/unstable/schemas.ts

@@ -1,6 +1,10 @@
 export {
   any_device_type,
-  capabilities as capabilities_supported,
+  battery_status,
+  capabilities,
+  climate_setting,
+  climate_setting_schedule,
+  common_device_properties,
   lock_device_type,
   managed_device,
   noise_sensor_device_type,