@seamapi/types 1.186.0 → 1.188.0

package/dist/connect.cjs

@@ -11,16 +11,272 @@ var __export = (target, all) => {
 // src/lib/seam/connect/schemas.ts
 var schemas_exports = {};
 __export(schemas_exports, {
+  access_code: () => access_code,
+  acs_access_group: () => acs_access_group,
+  acs_credential: () => acs_credential,
+  acs_entrance: () => acs_entrance,
+  acs_system: () => acs_system,
+  acs_user: () => acs_user,
   action_attempt: () => action_attempt,
   client_session: () => client_session,
   connect_webview: () => connect_webview,
   connected_account: () => connected_account,
   custom_metadata: () => custom_metadata,
+  device: () => device,
   seam_event: () => seam_event,
+  unmanaged_access_code: () => unmanaged_access_code,
+  unmanaged_device: () => unmanaged_device,
   user_identity: () => user_identity,
   webhook: () => webhook,
   workspace: () => workspace
 });
+var access_code = zod.z.object({
+  common_code_key: zod.z.string().nullable().describe(
+    "Unique identifier for a group of access codes that share the same code."
+  ),
+  is_scheduled_on_device: zod.z.boolean().optional().describe(
+    "Indicates whether the code is set on the device according to a preconfigured schedule."
+  ),
+  type: zod.z.enum(["time_bound", "ongoing"]).describe(
+    'Nature of the access code. Values are "ongoing" for access codes that are active continuously until deactivated manually or "time_bound" for access codes that have a specific duration.'
+  ),
+  is_waiting_for_code_assignment: zod.z.boolean().optional().describe(
+    "Indicates whether the access code is waiting for a code assignment."
+  ),
+  access_code_id: zod.z.string().uuid().describe("Unique identifier for the access code."),
+  device_id: zod.z.string().uuid().describe(
+    "Unique identifier for the device associated with the access code."
+  ),
+  name: zod.z.string().nullable().describe(
+    "Name of the access code. Enables administrators and users to identify the access code easily, especially when there are numerous access codes."
+  ),
+  code: zod.z.string().nullable().describe(
+    "Code used for access. Typically, a numeric or alphanumeric string."
+  ),
+  created_at: zod.z.string().datetime().describe("Date and time at which the access code was created."),
+  errors: zod.z.any().describe(
+    'Collection of errors associated with the access code, structured in a dictionary format. A unique "error_code" keys each error. Each error entry is an object containing two fields: "message" and "created_at." "message" is a string that describes the error. "created_at" is a date that indicates when the error was generated. This structure enables detailed tracking and timely response to critical issues.'
+  ),
+  warnings: zod.z.any().describe(
+    'Collection of warnings associated with the access code, structured in a dictionary format. A unique "warning_code" keys each warning. Each warning entry is an object containing two fields: "message" and "created_at." "message" is a string that describes the warning. "created_at" is a date that indicates when the warning was generated. This structure enables detailed tracking and timely response to potential issues that are not critical but that may require attention.'
+  ),
+  is_managed: zod.z.literal(true).describe("Indicates whether Seam manages the access code."),
+  starts_at: zod.z.string().datetime().nullable().optional().describe(
+    "Date and time at which the time-bound access code becomes active."
+  ),
+  ends_at: zod.z.string().datetime().nullable().optional().describe(
+    "Date and time after which the time-bound access code becomes inactive."
+  ),
+  status: zod.z.enum(["setting", "set", "unset", "removing", "unknown"]).describe(`
+    Current status of the access code within the operational lifecycle. Values are "setting," a transitional phase that indicates that the code is being configured or activated; "set", which indicates that the code is active and operational; "unset," which indicates a deactivated or unused state, either before activation or after deliberate deactivation; "removing," which indicates a transitional period in which the code is being deleted or made inactive; and "unknown," which indicates an indeterminate state, due to reasons such as system errors or incomplete data, that highlights a potential need for system review or troubleshooting.
+  `),
+  is_backup_access_code_available: zod.z.boolean().describe(
+    "Indicates whether a backup access code is available for use if the primary access code is lost or compromised."
+  ),
+  is_backup: zod.z.boolean().optional().describe("Indicates whether the access code is a backup code."),
+  pulled_backup_access_code_id: zod.z.string().uuid().nullable().optional().describe(
+    "Identifier of the pulled backup access code. Used to associate the pulled backup access code with the original access code."
+  ),
+  is_external_modification_allowed: zod.z.boolean().describe(
+    "Indicates whether changes to the access code from external sources are permitted."
+  ),
+  is_one_time_use: zod.z.boolean().describe(
+    'Indicates whether the access code can only be used once. If "true," the code becomes invalid after the first use.'
+  ),
+  is_offline_access_code: zod.z.boolean().describe(
+    'Indicates whether the access code is intended for use in offline scenarios. If "true," this code can be created on a device without a network connection.'
+  )
+});
+var unmanaged_access_code = access_code.pick({
+  type: true,
+  access_code_id: true,
+  device_id: true,
+  name: true,
+  code: true,
+  created_at: true,
+  errors: true,
+  warnings: true,
+  is_managed: true,
+  starts_at: true,
+  ends_at: true
+}).extend({
+  is_managed: zod.z.literal(false),
+  status: zod.z.enum(["set"])
+});
+var acs_access_group_external_type = zod.z.enum([
+  "pti_unit",
+  "pti_access_level",
+  "salto_access_group",
+  "brivo_group"
+]);
+var acs_access_group = zod.z.object({
+  acs_access_group_id: zod.z.string().uuid(),
+  acs_system_id: zod.z.string().uuid(),
+  workspace_id: zod.z.string().uuid(),
+  name: zod.z.string(),
+  access_group_type: acs_access_group_external_type.describe(`
+    ---
+    deprecated: use external_type
+    ---
+  `),
+  access_group_type_display_name: zod.z.string().describe(`
+    ---
+    deprecated: use external_type_display_name
+    ---
+    `),
+  display_name: zod.z.string(),
+  external_type: acs_access_group_external_type,
+  external_type_display_name: zod.z.string(),
+  created_at: zod.z.string().datetime()
+});
+var acs_entrance_latch_metadata = zod.z.object({
+  accessibility_type: zod.z.string(),
+  door_name: zod.z.string(),
+  door_type: zod.z.string(),
+  is_connected: zod.z.boolean()
+});
+var acs_entrance_visionline_metadata = zod.z.object({
+  door_name: zod.z.string(),
+  door_category: zod.z.enum([
+    "entrance",
+    "guest",
+    "elevator reader",
+    "common",
+    "common (PMS)"
+  ]),
+  profiles: zod.z.array(
+    zod.z.object({
+      visionline_door_profile_id: zod.z.string(),
+      visionline_door_profile_type: zod.z.enum(["BLE", "commonDoor", "touch"])
+    })
+  ).optional()
+});
+var acs_credential_visionline_metadata = zod.z.object({
+  card_function_type: zod.z.enum(["guest", "staff"]),
+  joiner_acs_credential_ids: zod.z.array(zod.z.string().uuid()).optional(),
+  guest_acs_entrance_ids: zod.z.array(zod.z.string().uuid()).optional(),
+  common_acs_entrance_ids: zod.z.array(zod.z.string().uuid()).optional()
+});
+
+// src/lib/seam/connect/models/acs/acs-credential.ts
+var acs_credential_external_type = zod.z.enum([
+  "pti_card",
+  "brivo_credential",
+  "hid_credential",
+  "visionline_card"
+]);
+var acs_credential_access_method_type = zod.z.enum([
+  "code",
+  "card",
+  "mobile_key"
+]);
+var acs_credential = zod.z.object({
+  acs_credential_id: zod.z.string().uuid(),
+  acs_user_id: zod.z.string().uuid().optional(),
+  acs_credential_pool_id: zod.z.string().uuid().optional(),
+  acs_system_id: zod.z.string().uuid(),
+  parent_acs_credential_id: zod.z.string().uuid().optional(),
+  display_name: zod.z.string().min(1),
+  code: zod.z.string().optional().nullable(),
+  access_method: acs_credential_access_method_type,
+  external_type: acs_credential_external_type.optional(),
+  external_type_display_name: zod.z.string().optional(),
+  created_at: zod.z.string().datetime(),
+  workspace_id: zod.z.string().uuid(),
+  starts_at: zod.z.string().optional(),
+  ends_at: zod.z.string().optional(),
+  errors: zod.z.array(
+    zod.z.object({
+      error_code: zod.z.string(),
+      message: zod.z.string()
+    })
+  ),
+  warnings: zod.z.array(
+    zod.z.object({
+      warning_code: zod.z.string(),
+      message: zod.z.string()
+    })
+  ),
+  is_multi_phone_sync_credential: zod.z.boolean().optional(),
+  is_latest_desired_state_synced_with_provider: zod.z.boolean().optional(),
+  latest_desired_state_synced_with_provider_at: zod.z.string().datetime().optional(),
+  visionline_metadata: acs_credential_visionline_metadata.optional()
+});
+var acs_entrance = zod.z.object({
+  acs_system_id: zod.z.string().uuid(),
+  acs_entrance_id: zod.z.string().uuid(),
+  created_at: zod.z.string().datetime(),
+  display_name: zod.z.string(),
+  errors: zod.z.array(
+    zod.z.object({
+      error_code: zod.z.string(),
+      message: zod.z.string()
+    })
+  ),
+  latch_metadata: acs_entrance_latch_metadata.optional(),
+  visionline_metadata: acs_entrance_visionline_metadata.optional()
+});
+var acs_system_capability_flags = zod.z.object({
+  can_automate_enrollment: zod.z.boolean().optional(),
+  can_create_acs_access_groups: zod.z.boolean().optional(),
+  can_remove_acs_users_from_acs_access_groups: zod.z.boolean().optional(),
+  can_add_acs_users_to_acs_access_groups: zod.z.boolean().optional()
+});
+var acs_system_external_type = zod.z.enum([
+  "pti_site",
+  "alta_org",
+  "salto_site",
+  "brivo_account",
+  "hid_credential_manager_organization",
+  "visionline_system",
+  "assa_abloy_credential_service",
+  "latch_building"
+]);
+var common_acs_system_error = zod.z.object({
+  created_at: zod.z.string().datetime(),
+  message: zod.z.string()
+});
+var seam_bridge_disconnected = common_acs_system_error.extend({
+  error_code: zod.z.literal("seam_bridge_disconnected")
+});
+var visionline_instance_unreachable = common_acs_system_error.extend({
+  error_code: zod.z.literal("visionline_instance_unreachable")
+});
+var acs_system_error = zod.z.union([
+  seam_bridge_disconnected,
+  visionline_instance_unreachable
+]);
+zod.z.object({
+  seam_bridge_disconnected: seam_bridge_disconnected.optional().nullable(),
+  visionline_instance_unreachable: visionline_instance_unreachable.optional().nullable()
+});
+var acs_system_warning = zod.z.object({});
+zod.z.object({});
+var acs_system = zod.z.object({
+  acs_system_id: zod.z.string().uuid(),
+  external_type: acs_system_external_type.optional(),
+  external_type_display_name: zod.z.string().optional(),
+  system_type: acs_system_external_type.describe(
+    `
+      ---
+      deprecated: use external_type
+      ---
+      `
+  ).optional(),
+  system_type_display_name: zod.z.string().optional().describe(`
+      ---
+      deprecated: use external_type_display_name
+      ---
+      `),
+  name: zod.z.string(),
+  created_at: zod.z.string().datetime(),
+  workspace_id: zod.z.string().uuid(),
+  connected_account_ids: zod.z.array(zod.z.string().uuid()),
+  image_url: zod.z.string(),
+  image_alt_text: zod.z.string(),
+  errors: zod.z.array(acs_system_error),
+  warnings: zod.z.array(acs_system_warning)
+}).merge(acs_system_capability_flags);
 var phone_number = zod.z.coerce.string().trim().refine(
   (val) => {
     return /^\+[1-9]\d{1,14}$/.test(val);
@@ -29,6 +285,46 @@ var phone_number = zod.z.coerce.string().trim().refine(
     message: "Phone number must be in E.164 format: +14155552671"
   }
 );
+var start_end_schedule = zod.z.object({
+  starts_at: zod.z.string().datetime(),
+  ends_at: zod.z.string().datetime()
+});
+var schedule = start_end_schedule;
+
+// src/lib/seam/connect/models/acs/acs-user.ts
+var acs_user_external_type = zod.z.enum([
+  "pti_user",
+  "brivo_user",
+  "hid_credential_manager_user",
+  "salto_site_user",
+  "latch_user"
+]);
+var user_fields = zod.z.object({
+  full_name: zod.z.string().optional(),
+  email: zod.z.string().email().optional().describe(`
+    ---
+    deprecated: use email_address.
+    ---
+    `),
+  email_address: zod.z.string().email().optional(),
+  phone_number: phone_number.optional()
+});
+var acs_user = zod.z.object({
+  acs_user_id: zod.z.string().uuid(),
+  acs_system_id: zod.z.string().uuid(),
+  hid_acs_system_id: zod.z.string().uuid().optional(),
+  workspace_id: zod.z.string().uuid(),
+  created_at: zod.z.string().datetime(),
+  display_name: zod.z.string(),
+  external_type: acs_user_external_type.optional(),
+  external_type_display_name: zod.z.string().optional(),
+  is_suspended: zod.z.boolean(),
+  access_schedule: schedule.optional(),
+  user_identity_id: zod.z.string().optional(),
+  user_identity_full_name: zod.z.string().nullable().optional(),
+  user_identity_email_address: zod.z.string().nullable().optional(),
+  user_identity_phone_number: zod.z.string().nullable().optional()
+}).merge(user_fields);
 var common_action_attempt = zod.z.object({
   action_attempt_id: zod.z.string().uuid().describe(`
     ---
@@ -387,6 +683,772 @@ var connected_account = zod.z.object({
   custom_metadata,
   automatically_manage_new_devices: zod.z.boolean()
 });
+var capabilities = zod.z.enum([
+  "access_code",
+  "lock",
+  "noise_detection",
+  "thermostat",
+  "battery",
+  "phone"
+]);
+var access_code_code_constraint = zod.z.object({
+  constraint_type: zod.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
+    "no_ascending_or_descending_sequence",
+    // Tedee
+    "at_least_three_unique_digits",
+    // Tedee
+    "cannot_contain_089"
+    // TTLock (for some cylinder devices only)
+  ])
+});
+var access_code_name_constraint = zod.z.object({
+  constraint_type: zod.z.enum(["name_length", "name_must_be_unique"]),
+  // Nuki, Kwikset
+  min_length: zod.z.number().optional(),
+  max_length: zod.z.number().optional()
+});
+var access_code_constraint = zod.z.union([
+  access_code_code_constraint,
+  access_code_name_constraint
+]);
+var access_code_capability_properties = zod.z.object({
+  _experimental_supported_code_from_access_codes_lengths: zod.z.array(zod.z.number()).optional(),
+  code_constraints: zod.z.array(access_code_constraint).optional(),
+  supported_code_lengths: zod.z.array(zod.z.number()).optional(),
+  max_active_codes_supported: zod.z.number().optional(),
+  supports_backup_access_code_pool: zod.z.boolean().optional(),
+  has_native_entry_events: zod.z.boolean().optional()
+});
+var lock_capability_properties = zod.z.object({
+  locked: zod.z.boolean().optional(),
+  keypad_battery: zod.z.object({
+    level: zod.z.number()
+  }).optional(),
+  door_open: zod.z.boolean().optional()
+});
+var hvac_mode_setting = zod.z.enum(["off", "heat", "cool", "heat_cool"]);
+var fan_mode_setting = zod.z.enum(["auto", "on"]);
+var climate_setting = zod.z.object({
+  automatic_heating_enabled: zod.z.boolean(),
+  automatic_cooling_enabled: zod.z.boolean(),
+  hvac_mode_setting,
+  cooling_set_point_celsius: zod.z.number().optional(),
+  heating_set_point_celsius: zod.z.number().optional(),
+  cooling_set_point_fahrenheit: zod.z.number().optional(),
+  heating_set_point_fahrenheit: zod.z.number().optional(),
+  manual_override_allowed: zod.z.boolean()
+});
+var climate_setting_schedule = zod.z.object({
+  climate_setting_schedule_id: zod.z.string().uuid(),
+  schedule_type: zod.z.literal("time_bound"),
+  device_id: zod.z.string().uuid(),
+  name: zod.z.string().optional(),
+  schedule_starts_at: zod.z.string(),
+  schedule_ends_at: zod.z.string(),
+  created_at: zod.z.string().datetime(),
+  errors: zod.z.any().describe(
+    'Collection of errors associated with the access code, structured in a dictionary format. A unique "error_code" keys each error. Each error entry is an object containing two fields: "message" and "created_at." "message" is a string that describes the error. "created_at" is a date that indicates when the error was generated. This structure enables detailed tracking and timely response to critical issues.'
+  )
+}).merge(climate_setting.partial());
+var base_thermostat_capability_properties = zod.z.object({
+  temperature_fahrenheit: zod.z.number(),
+  temperature_celsius: zod.z.number(),
+  relative_humidity: zod.z.number().min(0).max(1),
+  can_enable_automatic_heating: zod.z.boolean(),
+  can_enable_automatic_cooling: zod.z.boolean(),
+  available_hvac_mode_settings: zod.z.array(hvac_mode_setting),
+  is_heating_available: zod.z.literal(false),
+  is_cooling_available: zod.z.literal(false),
+  is_heating: zod.z.boolean(),
+  is_cooling: zod.z.boolean(),
+  is_fan_running: zod.z.boolean(),
+  fan_mode_setting,
+  /**
+   * 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: zod.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: zod.z.boolean(),
+  active_climate_setting_schedule: climate_setting_schedule.optional()
+});
+var cooling_thermostat_capability_properties = base_thermostat_capability_properties.merge(
+  zod.z.object({
+    min_cooling_set_point_celsius: zod.z.number(),
+    min_cooling_set_point_fahrenheit: zod.z.number(),
+    max_cooling_set_point_celsius: zod.z.number(),
+    max_cooling_set_point_fahrenheit: zod.z.number(),
+    is_cooling_available: zod.z.literal(true)
+  })
+);
+var heating_thermostat_capability_properties = base_thermostat_capability_properties.merge(
+  zod.z.object({
+    min_heating_set_point_celsius: zod.z.number(),
+    min_heating_set_point_fahrenheit: zod.z.number(),
+    max_heating_set_point_celsius: zod.z.number(),
+    max_heating_set_point_fahrenheit: zod.z.number(),
+    is_heating_available: zod.z.literal(true)
+  })
+);
+var heating_cooling_thermostat_capability_properties = cooling_thermostat_capability_properties.merge(heating_thermostat_capability_properties).merge(
+  zod.z.object({
+    is_cooling_available: zod.z.literal(true),
+    is_heating_available: zod.z.literal(true),
+    min_heating_cooling_delta_celsius: zod.z.number(),
+    min_heating_cooling_delta_fahrenheit: zod.z.number()
+  })
+);
+var thermostat_capability_properties = zod.z.union([
+  heating_cooling_thermostat_capability_properties.partial(),
+  heating_thermostat_capability_properties.partial(),
+  cooling_thermostat_capability_properties.partial()
+]);
+
+// src/lib/seam/connect/models/devices/capability-properties/index.ts
+var capability_properties = zod.z.intersection(
+  access_code_capability_properties.partial().merge(lock_capability_properties.partial()),
+  thermostat_capability_properties
+);
+
+// src/lib/seam/devicedb/models/index.ts
+var models_exports = {};
+__export(models_exports, {
+  base_device_model_v1: () => base_device_model_v1,
+  device_capability_flags: () => device_capability_flags,
+  device_category: () => device_category,
+  device_connection_type: () => device_connection_type,
+  device_model_category_specific_properties: () => device_model_category_specific_properties,
+  device_model_v1: () => device_model_v1,
+  image_reference: () => image_reference,
+  manufacturer: () => manufacturer,
+  manufacturer_annotation: () => manufacturer_annotation,
+  manufacturer_annotation_code: () => manufacturer_annotation_code,
+  manufacturer_integration_support_level: () => manufacturer_integration_support_level,
+  thermostat: () => thermostat
+});
+var device_capability_flags = zod.z.object({
+  can_remotely_unlock: zod.z.boolean(),
+  can_remotely_lock: zod.z.boolean(),
+  can_program_offline_access_codes: zod.z.boolean(),
+  can_program_online_access_codes: zod.z.boolean()
+}).partial();
+var device_model_capability_flags_map = {
+  can_remotely_lock: zod.z.literal(true),
+  can_remotely_unlock: zod.z.literal(true),
+  can_program_offline_access_codes: zod.z.literal(true),
+  can_program_online_access_codes: zod.z.literal(true)
+};
+var device_model_capability_flags = zod.z.object(device_model_capability_flags_map).partial();
+var hardware = zod.z.object({
+  has_physical_key: zod.z.boolean()
+}).partial();
+var image_reference = zod.z.object({
+  url: zod.z.string().url(),
+  width: zod.z.number(),
+  height: zod.z.number()
+});
+var manufacturer_integration_support_level = zod.z.enum([
+  "stable",
+  "beta",
+  "planned",
+  "unsupported",
+  "inquire"
+]);
+var manufacturer_annotation_code = zod.z.enum(["subscription_required"]);
+var manufacturer_annotation = zod.z.object({
+  annotation_code: manufacturer_annotation_code,
+  message: zod.z.string().trim().nonempty()
+});
+var manufacturer = zod.z.object({
+  manufacturer_id: zod.z.string().uuid(),
+  display_name: zod.z.string(),
+  logo: image_reference.optional(),
+  /** @deprecated */
+  integration: manufacturer_integration_support_level,
+  integration_support_level: manufacturer_integration_support_level,
+  is_connect_webview_supported: zod.z.boolean(),
+  requires_seam_support_to_add_account: zod.z.boolean(),
+  device_model_count: zod.z.number(),
+  annotations: zod.z.array(manufacturer_annotation),
+  website: zod.z.string().url().optional(),
+  legal_name: zod.z.string().optional(),
+  parent_organization: zod.z.string().optional(),
+  headquarters: zod.z.array(zod.z.string()).optional(),
+  countries_of_origin: zod.z.array(zod.z.string()).optional(),
+  founding_year: zod.z.string().optional(),
+  us_customer_support_tel: zod.z.string().optional(),
+  us_customer_support_email: zod.z.string().email().optional(),
+  us_customer_support_contact_url: zod.z.string().url().optional(),
+  seam_api_guide: zod.z.string().optional(),
+  description: zod.z.string().optional()
+});
+
+// src/lib/seam/devicedb/models/device-model.ts
+var device_category = zod.z.enum([
+  "smartlock",
+  "sensor",
+  "thermostat",
+  "relay",
+  "intercom",
+  "accessory"
+]);
+var device_connection_type = zod.z.enum([
+  "wifi",
+  "zwave",
+  "zigbee",
+  "unknown"
+]);
+var smartlock = zod.z.object({
+  main_category: zod.z.literal(device_category.enum.smartlock),
+  physical_properties: zod.z.object({
+    lock_type: zod.z.enum([
+      "deadbolt",
+      "lever",
+      "mortise",
+      "lockbox",
+      "cylinder",
+      "padlock",
+      "locker",
+      "unknown"
+    ]),
+    has_physical_key: zod.z.boolean(),
+    has_camera: zod.z.boolean()
+  }),
+  software_features: zod.z.object({
+    can_remotely_unlock: zod.z.boolean(),
+    can_program_access_codes: zod.z.boolean(),
+    can_program_access_schedules: zod.z.boolean(),
+    can_program_access_codes_offline: zod.z.boolean()
+  })
+}).merge(
+  device_model_capability_flags.pick({
+    can_remotely_lock: true,
+    can_remotely_unlock: true,
+    can_program_offline_access_codes: true,
+    can_program_online_access_codes: true
+  })
+);
+var sensor = zod.z.object({
+  main_category: zod.z.literal(device_category.enum.sensor),
+  physical_properties: zod.z.object({
+    has_noise_sensor: zod.z.boolean(),
+    has_humidity_sensor: zod.z.boolean(),
+    has_temperature_sensor: zod.z.boolean(),
+    has_occupancy_detection: zod.z.boolean()
+  })
+});
+var thermostat = zod.z.object({
+  main_category: zod.z.literal(device_category.enum.thermostat),
+  physical_properties: zod.z.object({
+    available_modes: zod.z.enum(["heat", "cool", "fan", "eco"]).array(),
+    is_heat_pump_compatible: zod.z.boolean(),
+    has_occupancy_detection: zod.z.boolean(),
+    supports_demand_response: zod.z.boolean(),
+    has_humidity_sensor: zod.z.boolean(),
+    has_temperature_sensor: zod.z.boolean(),
+    supports_emergency_heating_mode: zod.z.boolean()
+  }),
+  software_features: zod.z.object({
+    can_program_climate_schedules: zod.z.boolean()
+  })
+});
+var relay = zod.z.object({
+  main_category: zod.z.literal(device_category.enum.relay)
+});
+var intercom = zod.z.object({
+  main_category: zod.z.literal(device_category.enum.intercom),
+  physical_properties: zod.z.object({
+    has_camera: zod.z.boolean(),
+    has_rfid_reader: zod.z.boolean().default(false),
+    has_nfc_reader: zod.z.boolean().default(false),
+    has_wiegand_interface: zod.z.boolean().default(false)
+  }),
+  software_features: zod.z.object({
+    can_remotely_unlock: zod.z.boolean(),
+    can_program_access_codes: zod.z.boolean(),
+    can_unlock_with_face_recognition: zod.z.boolean().default(false),
+    supports_onvif: zod.z.boolean().default(false)
+  })
+});
+var accessory = zod.z.object({
+  main_category: zod.z.literal(device_category.enum.accessory)
+});
+var device_model_category_specific_properties = zod.z.discriminatedUnion(
+  "main_category",
+  [smartlock, sensor, thermostat, relay, intercom, accessory]
+);
+var base_device_model_v1 = zod.z.object({
+  device_model_id: zod.z.string().uuid(),
+  manufacturer: manufacturer.omit({
+    device_model_count: true
+  }),
+  is_device_supported: zod.z.boolean(),
+  display_name: zod.z.string(),
+  description: zod.z.string(),
+  product_url: zod.z.string().optional(),
+  main_connection_type: device_connection_type,
+  hardware,
+  aesthetic_variants: zod.z.object({
+    slug: zod.z.string(),
+    display_name: zod.z.string(),
+    primary_color_hex: zod.z.string().optional(),
+    manufacturer_sku: zod.z.string().optional(),
+    front_image: image_reference.optional(),
+    back_image: image_reference.optional(),
+    images: image_reference.array()
+  }).array(),
+  power_sources: zod.z.enum([
+    "battery",
+    "hardwired",
+    "mechanical_harvesting",
+    "wireless",
+    "ethernet"
+  ]).array()
+});
+var device_model_v1 = base_device_model_v1.and(
+  device_model_category_specific_properties
+);
+var dormakaba_oracode_time_slot = zod.z.object({
+  name: zod.z.string(),
+  prefix: zod.z.number(),
+  // Seam TOD
+  check_in_time: zod.z.string(),
+  // Seam TOD
+  check_out_time: zod.z.string(),
+  is_24_hour: zod.z.boolean(),
+  is_biweekly_mode: zod.z.boolean(),
+  is_one_shot: zod.z.boolean(),
+  is_master: zod.z.boolean(),
+  ext_dormakaba_oracode_user_level_prefix: zod.z.number(),
+  dormakaba_oracode_user_level_id: zod.z.string().uuid()
+});
+var device_metadata = zod.z.object({
+  august_metadata: zod.z.object({
+    lock_id: zod.z.string(),
+    lock_name: zod.z.string(),
+    house_name: zod.z.string(),
+    has_keypad: zod.z.boolean(),
+    keypad_battery_level: zod.z.string().optional(),
+    model: zod.z.string().optional(),
+    house_id: zod.z.string().optional()
+  }),
+  avigilon_alta_metadata: zod.z.object({
+    entry_name: zod.z.string(),
+    org_name: zod.z.string(),
+    zone_id: zod.z.number(),
+    zone_name: zod.z.string(),
+    site_id: zod.z.number(),
+    site_name: zod.z.string(),
+    entry_relays_total_count: zod.z.number()
+  }),
+  schlage_metadata: zod.z.object({
+    device_id: zod.z.string(),
+    device_name: zod.z.string(),
+    access_code_length: zod.z.number().nullable(),
+    model: zod.z.string().optional()
+  }),
+  smartthings_metadata: zod.z.object({
+    device_id: zod.z.string(),
+    device_name: zod.z.string(),
+    model: zod.z.string().optional(),
+    location_id: zod.z.string().optional()
+  }),
+  lockly_metadata: zod.z.object({
+    device_id: zod.z.string(),
+    device_name: zod.z.string(),
+    model: zod.z.string().optional()
+  }),
+  nuki_metadata: zod.z.object({
+    device_id: zod.z.string(),
+    device_name: zod.z.string(),
+    keypad_battery_critical: zod.z.boolean().optional(),
+    keypad_paired: zod.z.boolean().optional(),
+    keypad_2_paired: zod.z.boolean().optional()
+  }),
+  kwikset_metadata: zod.z.object({
+    device_id: zod.z.string(),
+    device_name: zod.z.string(),
+    model_number: zod.z.string()
+  }),
+  salto_metadata: zod.z.object({
+    lock_id: zod.z.string(),
+    customer_reference: zod.z.string(),
+    lock_type: zod.z.string(),
+    battery_level: zod.z.string(),
+    locked_state: zod.z.string(),
+    model: zod.z.string().optional()
+  }),
+  genie_metadata: zod.z.object({
+    device_name: zod.z.string(),
+    door_name: zod.z.string()
+  }),
+  brivo_metadata: zod.z.object({
+    device_name: zod.z.string()
+  }),
+  igloo_metadata: zod.z.object({
+    device_id: zod.z.string(),
+    bridge_id: zod.z.string(),
+    model: zod.z.string().optional()
+  }),
+  noiseaware_metadata: zod.z.object({
+    device_model: zod.z.enum(["indoor", "outdoor"]),
+    noise_level_nrs: zod.z.number(),
+    noise_level_decibel: zod.z.number(),
+    device_name: zod.z.string(),
+    device_id: zod.z.string()
+  }),
+  minut_metadata: zod.z.object({
+    device_id: zod.z.string(),
+    device_name: zod.z.string(),
+    latest_sensor_values: zod.z.object({
+      temperature: zod.z.object({
+        time: zod.z.string(),
+        value: zod.z.number()
+      }),
+      sound: zod.z.object({
+        time: zod.z.string(),
+        value: zod.z.number()
+      }),
+      humidity: zod.z.object({
+        time: zod.z.string(),
+        value: zod.z.number()
+      }),
+      pressure: zod.z.object({
+        time: zod.z.string(),
+        value: zod.z.number()
+      }),
+      accelerometer_z: zod.z.object({
+        time: zod.z.string(),
+        value: zod.z.number()
+      })
+    })
+  }),
+  four_suites_metadata: zod.z.object({
+    device_id: zod.z.number(),
+    device_name: zod.z.string(),
+    reclose_delay_in_seconds: zod.z.number()
+  }),
+  two_n_metadata: zod.z.object({
+    device_id: zod.z.number(),
+    device_name: zod.z.string()
+  }),
+  controlbyweb_metadata: zod.z.object({
+    device_id: zod.z.string(),
+    device_name: zod.z.string(),
+    relay_name: zod.z.string().nullable()
+  }),
+  ttlock_metadata: zod.z.object({
+    lock_id: zod.z.number(),
+    lock_alias: zod.z.string(),
+    feature_value: zod.z.string()
+  }),
+  seam_bridge_metadata: zod.z.object({
+    unlock_method: zod.z.enum(["bridge", "doorking"]).optional(),
+    device_num: zod.z.number(),
+    name: zod.z.string()
+  }),
+  igloohome_metadata: zod.z.object({
+    device_id: zod.z.string(),
+    device_name: zod.z.string(),
+    bridge_id: zod.z.string().optional(),
+    bridge_name: zod.z.string().optional(),
+    keypad_id: zod.z.string().optional()
+  }),
+  nest_metadata: zod.z.object({
+    nest_device_id: zod.z.string(),
+    device_name: zod.z.string(),
+    // set by Google
+    custom_name: zod.z.string()
+    // set by device owner
+  }),
+  ecobee_metadata: zod.z.object({
+    ecobee_device_id: zod.z.string(),
+    device_name: zod.z.string()
+  }),
+  honeywell_resideo_metadata: zod.z.object({
+    honeywell_resideo_device_id: zod.z.string(),
+    device_name: zod.z.string()
+  }),
+  hubitat_metadata: zod.z.object({
+    device_id: zod.z.string(),
+    device_name: zod.z.string(),
+    device_label: zod.z.string()
+  }),
+  dormakaba_oracode_metadata: zod.z.object({
+    door_id: zod.z.number(),
+    door_name: zod.z.string(),
+    device_id: zod.z.number().optional(),
+    door_is_wireless: zod.z.boolean(),
+    site_id: zod.z.number(),
+    site_name: zod.z.string(),
+    iana_timezone: zod.z.string().optional(),
+    predefined_time_slots: zod.z.array(dormakaba_oracode_time_slot).optional()
+  }),
+  wyze_metadata: zod.z.object({
+    device_id: zod.z.string(),
+    device_name: zod.z.string(),
+    product_name: zod.z.string(),
+    product_type: zod.z.string(),
+    product_model: zod.z.string(),
+    device_info_model: zod.z.string(),
+    keypad_uuid: zod.z.string().optional(),
+    locker_status_hardlock: zod.z.number().optional()
+  }),
+  tedee_metadata: zod.z.object({
+    device_id: zod.z.number(),
+    serial_number: zod.z.string(),
+    device_name: zod.z.string(),
+    device_model: zod.z.string(),
+    bridge_id: zod.z.number(),
+    bridge_name: zod.z.string(),
+    keypad_id: zod.z.number().optional()
+  })
+}).partial();
+var LOCK_DEVICE_TYPE = {
+  AKUVOX_LOCK: "akuvox_lock",
+  AUGUST_LOCK: "august_lock",
+  BRIVO_ACCESS_POINT: "brivo_access_point",
+  BUTTERFLYMX_PANEL: "butterflymx_panel",
+  AVIGILON_ALTA_ENTRY: "avigilon_alta_entry",
+  DOORKING_LOCK: "doorking_lock",
+  GENIE_DOOR: "genie_door",
+  IGLOO_LOCK: "igloo_lock",
+  LINEAR_LOCK: "linear_lock",
+  LOCKLY_LOCK: "lockly_lock",
+  KWIKSET_LOCK: "kwikset_lock",
+  NUKI_LOCK: "nuki_lock",
+  SALTO_LOCK: "salto_lock",
+  SCHLAGE_LOCK: "schlage_lock",
+  SEAM_RELAY: "seam_relay",
+  SMARTTHINGS_LOCK: "smartthings_lock",
+  WYZE_LOCK: "wyze_lock",
+  YALE_LOCK: "yale_lock",
+  TWO_N_INTERCOM: "two_n_intercom",
+  CONTROLBYWEB_DEVICE: "controlbyweb_device",
+  TTLOCK_LOCK: "ttlock_lock",
+  IGLOOHOME_LOCK: "igloohome_lock",
+  HUBITAT_LOCK: "hubitat_lock",
+  FOUR_SUITES_DOOR: "four_suites_door",
+  DORMAKABA_ORACODE_DOOR: "dormakaba_oracode_door",
+  TEDEE_LOCK: "tedee_lock"
+};
+var lock_device_type = zod.z.enum(
+  Object.values(LOCK_DEVICE_TYPE)
+);
+var NOISE_SENSOR_DEVICE_TYPE = {
+  NOISEAWARE_ACTIVITY_ZONE: "noiseaware_activity_zone",
+  MINUT_SENSOR: "minut_sensor"
+};
+var noise_sensor_device_type = zod.z.enum(
+  Object.values(NOISE_SENSOR_DEVICE_TYPE)
+);
+var THERMOSTAT_DEVICE_TYPE = {
+  ECOBEE_THERMOSTAT: "ecobee_thermostat",
+  NEST_THERMOSTAT: "nest_thermostat",
+  HONEYWELL_RESIDEO_THERMOSTAT: "honeywell_resideo_thermostat"
+};
+var thermostat_device_type = zod.z.enum(
+  Object.values(THERMOSTAT_DEVICE_TYPE)
+);
+var PHONE_DEVICE_TYPE = {
+  IOS_PHONE: "ios_phone",
+  ANDROID_PHONE: "android_phone"
+};
+var PHONE_DEVICE_TYPE_LIST = Object.values(
+  PHONE_DEVICE_TYPE
+);
+var phone_device_type = zod.z.enum(
+  Object.values(PHONE_DEVICE_TYPE_LIST)
+);
+var any_device_type = zod.z.union([
+  lock_device_type,
+  noise_sensor_device_type,
+  thermostat_device_type,
+  phone_device_type
+]);
+var phone_specific_properties = zod.z.object({
+  assa_abloy_credential_service_metadata: zod.z.object({
+    has_active_endpoint: zod.z.boolean(),
+    endpoints: zod.z.array(
+      zod.z.object({
+        endpoint_id: zod.z.string(),
+        is_active: zod.z.boolean()
+      })
+    )
+  }).optional()
+});
+
+// src/lib/seam/connect/models/devices/device.ts
+var device_capability_flags2 = models_exports.device_capability_flags.extend({
+  can_simulate_removal: zod.z.boolean().optional(),
+  can_simulate_connection: zod.z.boolean().optional(),
+  can_simulate_disconnection: zod.z.boolean().optional()
+});
+var battery_status = zod.z.enum(["critical", "low", "good", "full"]);
+var common_device_properties = zod.z.object({
+  online: zod.z.boolean().describe("Indicates whether the device is online."),
+  name: zod.z.string().describe(`
+      ---
+      deprecated: use device.display_name instead
+      ---
+      Name of the device.
+      `),
+  accessory_keypad: zod.z.object({
+    is_connected: zod.z.boolean().describe(
+      "Indicates if the accessory_keypad is connected to the device."
+    ),
+    battery: zod.z.object({
+      level: zod.z.number().min(0).max(1)
+    }).optional().describe("Indicates if the keypad battery properties.")
+  }).optional().describe("Represents the accessory keypad state."),
+  appearance: zod.z.object({
+    name: zod.z.string().describe(
+      "Name of the device as seen from the provider API and application, not settable through Seam."
+    )
+  }),
+  model: zod.z.object({
+    can_connect_accessory_keypad: zod.z.boolean().optional().describe("Indicates whether the device can connect a accessory keypad."),
+    display_name: zod.z.string().describe("Display name of the device model."),
+    manufacturer_display_name: zod.z.string().describe(
+      "Display name that corresponds to the manufacturer-specific terminology for the device."
+    ),
+    has_built_in_keypad: zod.z.boolean().optional().describe(
+      "Indicates whether the device has a built in accessory keypad."
+    ),
+    offline_access_codes_supported: zod.z.boolean().optional().describe("Indicates whether the device supports offline access codes."),
+    online_access_codes_supported: zod.z.boolean().optional().describe("Indicates whether the device supports online access codes."),
+    accessory_keypad_supported: zod.z.boolean().optional().describe(
+      `
+      ---
+      deprecated: use device.properties.model.can_connect_accessory_keypad
+      ---
+      `
+    )
+  }),
+  has_direct_power: zod.z.boolean().optional().describe("Indicates whether the device has direct power."),
+  battery_level: zod.z.number().min(0).max(1).optional().describe(
+    "Indicates the battery level of the device as a decimal value between 0 and 1, inclusive."
+  ),
+  battery: zod.z.object({
+    level: zod.z.number().min(0).max(1),
+    status: battery_status
+  }).optional().describe(
+    'Represents the current status of the battery charge level. Values are "critical," which indicates an extremely low level, suggesting imminent shutdown or an urgent need for charging; "low," which signifies that the battery is under the preferred threshold and should be charged soon; "good," which denotes a satisfactory charge level, adequate for normal use without the immediate need for recharging; and "full," which represents a battery that is fully charged, providing the maximum duration of usage.'
+  ),
+  // todo: use enum
+  manufacturer: zod.z.string().optional().describe("Manufacturer of the device."),
+  image_url: zod.z.string().url().optional().describe("Image URL for the device."),
+  image_alt_text: zod.z.string().optional().describe("Alt text for the device image."),
+  serial_number: zod.z.string().optional().describe("Serial number of the device."),
+  online_access_codes_enabled: zod.z.boolean().describe(
+    "Indicates whether it is currently possible to use online access codes for the device."
+  ).optional(),
+  offline_access_codes_enabled: zod.z.boolean().describe(
+    "Indicates whether it is currently possible to use offline access codes for the device."
+  ).optional(),
+  // Deprecated legacy capability support props
+  supports_accessory_keypad: zod.z.boolean().describe(
+    `
+      ---
+      deprecated: use device.properties.model.can_connect_accessory_keypad
+      ---
+      `
+  ).optional(),
+  supports_offline_access_codes: zod.z.boolean().describe(
+    `
+      ---
+      deprecated: use offline_access_codes_enabled
+      ---
+      `
+  ).optional(),
+  noise_level_decibels: zod.z.number().describe(
+    "Indicates current noise level in decibels, if the device supports noise detection."
+  ).optional(),
+  currently_triggering_noise_threshold_ids: zod.z.array(zod.z.string()).describe("Array of noise threshold IDs that are currently triggering.").optional()
+});
+var device = zod.z.object({
+  device_id: zod.z.string().uuid().describe("Unique identifier for the device."),
+  device_type: any_device_type.describe("Type of the device."),
+  nickname: zod.z.string().optional().describe(
+    "Optional nickname to describe the device, settable through Seam"
+  ),
+  display_name: zod.z.string().describe(
+    "Display name of the device, defaults to nickname (if it is set) or properties.appearance.name otherwise. Enables administrators and users to identify the device easily, especially when there are numerous devices."
+  ),
+  capabilities_supported: zod.z.array(capabilities).describe(
+    'Collection of capabilities that the device supports when connected to Seam. Values are "access_code," which indicates that the device can manage and utilize digital PIN codes for secure access; "lock," which indicates that the device controls a door locking mechanism, enabling the remote opening and closing of doors and other entry points; "noise_detection," which indicates that the device supports monitoring and responding to ambient noise levels; "thermostat," which indicates that the device can regulate and adjust indoor temperatures; and "battery," which indicates that the device can manage battery life and health.'
+  ),
+  properties: common_device_properties.and(phone_specific_properties.partial()).and(device_metadata).and(capability_properties).describe("Properties of the device."),
+  location: zod.z.object({
+    location_name: zod.z.string().optional().describe("Name of the device location."),
+    timezone: zod.z.string().optional().describe("Time zone of the device location.")
+  }).nullable().describe("Location information for the device."),
+  connected_account_id: zod.z.string().uuid().describe(
+    "Unique identifier for the account associated with the device."
+  ),
+  workspace_id: zod.z.string().uuid().describe(
+    "Unique identifier for the Seam workspace associated with the device."
+  ),
+  errors: zod.z.array(
+    zod.z.object({
+      error_code: zod.z.string(),
+      message: zod.z.string()
+    })
+  ).describe(
+    'Array of errors associated with the device. Each error object within the array contains two fields: "error_code" and "message." "error_code" is a string that uniquely identifies the type of error, enabling quick recognition and categorization of the issue. "message" provides a more detailed description of the error, offering insights into the issue and potentially how to rectify it.'
+  ),
+  warnings: zod.z.array(
+    zod.z.object({
+      warning_code: zod.z.string(),
+      message: zod.z.string()
+    })
+  ).describe(
+    'Array of warnings associated with the device. Each warning object within the array contains two fields: "warning_code" and "message." "warning_code" is a string that uniquely identifies the type of warning, enabling quick recognition and categorization of the issue. "message" provides a more detailed description of the warning, offering insights into the issue and potentially how to rectify it.'
+  ),
+  created_at: zod.z.string().datetime().describe("Date and time at which the device object was created."),
+  is_managed: zod.z.literal(true).describe("Indicates whether Seam manages the device."),
+  custom_metadata
+}).merge(device_capability_flags2);
+var unmanaged_device = device.pick({
+  device_id: true,
+  device_type: true,
+  connected_account_id: true,
+  capabilities_supported: true,
+  workspace_id: true,
+  errors: true,
+  warnings: true,
+  created_at: true
+}).extend({
+  is_managed: zod.z.literal(false),
+  properties: common_device_properties.pick({
+    accessory_keypad: true,
+    name: true,
+    online: true,
+    manufacturer: true,
+    image_url: true,
+    image_alt_text: true,
+    battery_level: true,
+    battery: true,
+    online_access_codes_enabled: true,
+    offline_access_codes_enabled: true,
+    model: true
+  })
+}).merge(device_capability_flags2);
 var common_event = zod.z.object({
   workspace_id: zod.z.string().uuid().describe(`
     ---
@@ -1197,7 +2259,6 @@ var openapi_default = {
             type: "array"
           },
           latch_metadata: {
-            nullable: true,
             properties: {
               accessibility_type: { type: "string" },
               door_name: { type: "string" },
@@ -1213,7 +2274,6 @@ var openapi_default = {
             type: "object"
           },
           visionline_metadata: {
-            nullable: true,
             properties: {
               door_category: {
                 enum: [
@@ -1249,13 +2309,11 @@ var openapi_default = {
           }
         },
         required: [
-          "acs_entrance_id",
-          "display_name",
           "acs_system_id",
+          "acs_entrance_id",
           "created_at",
-          "latch_metadata",
-          "errors",
-          "visionline_metadata"
+          "display_name",
+          "errors"
         ],
         type: "object"
       },
@@ -1266,7 +2324,10 @@ var openapi_default = {
           can_automate_enrollment: { type: "boolean" },
           can_create_acs_access_groups: { type: "boolean" },
           can_remove_acs_users_from_acs_access_groups: { type: "boolean" },
-          connected_account_ids: { items: { type: "string" }, type: "array" },
+          connected_account_ids: {
+            items: { format: "uuid", type: "string" },
+            type: "array"
+          },
           created_at: { format: "date-time", type: "string" },
           errors: {
             items: {
@@ -2633,6 +3694,8 @@ var openapi_default = {
           can_program_online_access_codes: { type: "boolean" },
           can_remotely_lock: { type: "boolean" },
           can_remotely_unlock: { type: "boolean" },
+          can_simulate_connection: { type: "boolean" },
+          can_simulate_disconnection: { type: "boolean" },
           can_simulate_removal: { type: "boolean" },
           capabilities_supported: {
             description: 'Collection of capabilities that the device supports when connected to Seam. Values are "access_code," which indicates that the device can manage and utilize digital PIN codes for secure access; "lock," which indicates that the device controls a door locking mechanism, enabling the remote opening and closing of doors and other entry points; "noise_detection," which indicates that the device supports monitoring and responding to ambient noise levels; "thermostat," which indicates that the device can regulate and adjust indoor temperatures; and "battery," which indicates that the device can manage battery life and health.',
@@ -4025,6 +5088,8 @@ var openapi_default = {
           can_program_online_access_codes: { type: "boolean" },
           can_remotely_lock: { type: "boolean" },
           can_remotely_unlock: { type: "boolean" },
+          can_simulate_connection: { type: "boolean" },
+          can_simulate_disconnection: { type: "boolean" },
           can_simulate_removal: { type: "boolean" },
           capabilities_supported: {
             description: 'Collection of capabilities that the device supports when connected to Seam. Values are "access_code," which indicates that the device can manage and utilize digital PIN codes for secure access; "lock," which indicates that the device controls a door locking mechanism, enabling the remote opening and closing of doors and other entry points; "noise_detection," which indicates that the device supports monitoring and responding to ambient noise levels; "thermostat," which indicates that the device can regulate and adjust indoor temperatures; and "battery," which indicates that the device can manage battery life and health.',
@@ -4237,6 +5302,8 @@ var openapi_default = {
           can_program_online_access_codes: { type: "boolean" },
           can_remotely_lock: { type: "boolean" },
           can_remotely_unlock: { type: "boolean" },
+          can_simulate_connection: { type: "boolean" },
+          can_simulate_disconnection: { type: "boolean" },
           can_simulate_removal: { type: "boolean" },
           capabilities_supported: {
             description: 'Collection of capabilities that the device supports when connected to Seam. Values are "access_code," which indicates that the device can manage and utilize digital PIN codes for secure access; "lock," which indicates that the device controls a door locking mechanism, enabling the remote opening and closing of doors and other entry points; "noise_detection," which indicates that the device supports monitoring and responding to ambient noise levels; "thermostat," which indicates that the device can regulate and adjust indoor temperatures; and "battery," which indicates that the device can manage battery life and health.',
@@ -9051,7 +10118,9 @@ var openapi_default = {
                         "can_remotely_lock",
                         "can_program_offline_access_codes",
                         "can_program_online_access_codes",
-                        "can_simulate_removal"
+                        "can_simulate_removal",
+                        "can_simulate_connection",
+                        "can_simulate_disconnection"
                       ],
                       type: "string"
                     },
@@ -9064,7 +10133,9 @@ var openapi_default = {
                         "can_remotely_lock",
                         "can_program_offline_access_codes",
                         "can_program_online_access_codes",
-                        "can_simulate_removal"
+                        "can_simulate_removal",
+                        "can_simulate_connection",
+                        "can_simulate_disconnection"
                       ],
                       type: "string"
                     },
@@ -9211,6 +10282,88 @@ var openapi_default = {
         "x-fern-sdk-return-value": "device_providers"
       }
     },
+    "/devices/simulate/connect": {
+      post: {
+        operationId: "devicesSimulateConnectPost",
+        requestBody: {
+          content: {
+            "application/json": {
+              schema: {
+                properties: { device_id: { format: "uuid", type: "string" } },
+                required: ["device_id"],
+                type: "object"
+              }
+            }
+          }
+        },
+        responses: {
+          200: {
+            content: {
+              "application/json": {
+                schema: {
+                  properties: { ok: { type: "boolean" } },
+                  required: ["ok"],
+                  type: "object"
+                }
+              }
+            },
+            description: "OK"
+          },
+          400: { description: "Bad Request" },
+          401: { description: "Unauthorized" }
+        },
+        security: [
+          { api_key: [] },
+          { pat_with_workspace: [] },
+          { console_session: [] }
+        ],
+        summary: "/devices/simulate/connect",
+        tags: ["/devices"],
+        "x-fern-sdk-group-name": ["devices", "simulate"],
+        "x-fern-sdk-method-name": "connect"
+      }
+    },
+    "/devices/simulate/disconnect": {
+      post: {
+        operationId: "devicesSimulateDisconnectPost",
+        requestBody: {
+          content: {
+            "application/json": {
+              schema: {
+                properties: { device_id: { format: "uuid", type: "string" } },
+                required: ["device_id"],
+                type: "object"
+              }
+            }
+          }
+        },
+        responses: {
+          200: {
+            content: {
+              "application/json": {
+                schema: {
+                  properties: { ok: { type: "boolean" } },
+                  required: ["ok"],
+                  type: "object"
+                }
+              }
+            },
+            description: "OK"
+          },
+          400: { description: "Bad Request" },
+          401: { description: "Unauthorized" }
+        },
+        security: [
+          { api_key: [] },
+          { pat_with_workspace: [] },
+          { console_session: [] }
+        ],
+        summary: "/devices/simulate/disconnect",
+        tags: ["/devices"],
+        "x-fern-sdk-group-name": ["devices", "simulate"],
+        "x-fern-sdk-method-name": "disconnect"
+      }
+    },
     "/devices/simulate/remove": {
       post: {
         operationId: "devicesSimulateRemovePost",
@@ -9442,7 +10595,9 @@ var openapi_default = {
                         "can_remotely_lock",
                         "can_program_offline_access_codes",
                         "can_program_online_access_codes",
-                        "can_simulate_removal"
+                        "can_simulate_removal",
+                        "can_simulate_connection",
+                        "can_simulate_disconnection"
                       ],
                       type: "string"
                     },
@@ -9455,7 +10610,9 @@ var openapi_default = {
                         "can_remotely_lock",
                         "can_program_offline_access_codes",
                         "can_program_online_access_codes",
-                        "can_simulate_removal"
+                        "can_simulate_removal",
+                        "can_simulate_connection",
+                        "can_simulate_disconnection"
                       ],
                       type: "string"
                     },
@@ -10187,7 +11344,9 @@ var openapi_default = {
                         "can_remotely_lock",
                         "can_program_offline_access_codes",
                         "can_program_online_access_codes",
-                        "can_simulate_removal"
+                        "can_simulate_removal",
+                        "can_simulate_connection",
+                        "can_simulate_disconnection"
                       ],
                       type: "string"
                     },
@@ -10200,7 +11359,9 @@ var openapi_default = {
                         "can_remotely_lock",
                         "can_program_offline_access_codes",
                         "can_program_online_access_codes",
-                        "can_simulate_removal"
+                        "can_simulate_removal",
+                        "can_simulate_connection",
+                        "can_simulate_disconnection"
                       ],
                       type: "string"
                     },
@@ -11890,7 +13051,9 @@ var openapi_default = {
                         "can_remotely_lock",
                         "can_program_offline_access_codes",
                         "can_program_online_access_codes",
-                        "can_simulate_removal"
+                        "can_simulate_removal",
+                        "can_simulate_connection",
+                        "can_simulate_disconnection"
                       ],
                       type: "string"
                     },
@@ -11903,7 +13066,9 @@ var openapi_default = {
                         "can_remotely_lock",
                         "can_program_offline_access_codes",
                         "can_program_online_access_codes",
-                        "can_simulate_removal"
+                        "can_simulate_removal",
+                        "can_simulate_connection",
+                        "can_simulate_disconnection"
                       ],
                       type: "string"
                     },