@seamapi/types 1.175.0 → 1.177.0

package/dist/connect.cjs

@@ -1,26 +1,6 @@
 'use strict';
 
-var z10 = require('zod');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var z10__namespace = /*#__PURE__*/_interopNamespace(z10);
+var zod = require('zod');
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -31,75 +11,249 @@ var __export = (target, all) => {
 // src/lib/seam/connect/schemas.ts
 var schemas_exports = {};
 __export(schemas_exports, {
+  action_attempt: () => action_attempt,
   connect_webview: () => connect_webview,
   custom_metadata: () => custom_metadata,
   seam_event: () => seam_event
 });
-z10.z.record(
-  z10.z.string().max(40),
-  z10.z.union([z10.z.string().max(500), z10.z.boolean(), z10.z.null()])
+var common_action_attempt = zod.z.object({
+  action_attempt_id: zod.z.string().uuid().describe(`
+    ---
+    title: Action Attempt ID
+    ---
+    The ID of the action attempt.
+  `),
+  status: zod.z.enum(["pending", "success", "error"])
+});
+var common_pending_action_attempt = common_action_attempt.extend({
+  status: zod.z.literal("pending"),
+  result: zod.z.null(),
+  error: zod.z.null()
+});
+var common_succeeded_action_attempt = common_action_attempt.extend({
+  status: zod.z.literal("success"),
+  error: zod.z.null()
+});
+var common_failed_action_attempt = common_action_attempt.extend({
+  status: zod.z.literal("error"),
+  result: zod.z.null()
+});
+
+// src/lib/seam/connect/models/action-attempts/lock-door.ts
+var action_type = zod.z.literal("LOCK_DOOR");
+var error = zod.z.object({
+  type: zod.z.string(),
+  message: zod.z.string()
+});
+var result = zod.z.object({});
+var lock_door_action_attempt = zod.z.discriminatedUnion("status", [
+  common_pending_action_attempt.extend({
+    action_type
+  }).describe("Locking door."),
+  common_succeeded_action_attempt.extend({
+    action_type,
+    result
+  }).describe("Locking door succeeded."),
+  common_failed_action_attempt.extend({ action_type, error }).describe("Locking door failed.")
+]);
+var action_type2 = zod.z.literal("RESET_SANDBOX_WORKSPACE");
+var error2 = zod.z.object({
+  type: zod.z.string(),
+  message: zod.z.string()
+});
+var result2 = zod.z.object({});
+var reset_sandbox_workspace_action_attempt = zod.z.discriminatedUnion(
+  "status",
+  [
+    common_pending_action_attempt.extend({
+      action_type: action_type2
+    }).describe("Resetting sandbox workspace."),
+    common_succeeded_action_attempt.extend({
+      action_type: action_type2,
+      result: result2
+    }).describe("Resetting sandbox workspace succeeded."),
+    common_failed_action_attempt.extend({
+      action_type: action_type2,
+      error: error2
+    }).describe("Resetting sandbox workspace failed.")
+  ]
+);
+var action_type3 = zod.z.literal("SET_COOL");
+var error3 = zod.z.object({
+  type: zod.z.string(),
+  message: zod.z.string()
+});
+var result3 = zod.z.object({});
+var set_cool_action_attempt = zod.z.discriminatedUnion("status", [
+  common_pending_action_attempt.extend({
+    action_type: action_type3
+  }).describe("Setting HVAC to cool."),
+  common_succeeded_action_attempt.extend({
+    action_type: action_type3,
+    result: result3
+  }).describe("Setting HVAC to cool succeeded."),
+  common_failed_action_attempt.extend({ action_type: action_type3, error: error3 }).describe("Setting HVAC to cool failed.")
+]);
+var action_type4 = zod.z.literal("SET_FAN_MODE");
+var error4 = zod.z.object({
+  type: zod.z.string(),
+  message: zod.z.string()
+});
+var result4 = zod.z.object({});
+var set_fan_mode_action_attempt = zod.z.discriminatedUnion("status", [
+  common_pending_action_attempt.extend({
+    action_type: action_type4
+  }).describe("Setting fan mode."),
+  common_succeeded_action_attempt.extend({
+    action_type: action_type4,
+    result: result4
+  }).describe("Setting fan mode succeeded."),
+  common_failed_action_attempt.extend({ action_type: action_type4, error: error4 }).describe("Setting fan mode failed.")
+]);
+var action_type5 = zod.z.literal("SET_HEAT");
+var error5 = zod.z.object({
+  type: zod.z.string(),
+  message: zod.z.string()
+});
+var result5 = zod.z.object({});
+var set_heat_action_attempt = zod.z.discriminatedUnion("status", [
+  common_pending_action_attempt.extend({
+    action_type: action_type5
+  }).describe("Setting HVAC to heat mode."),
+  common_succeeded_action_attempt.extend({
+    action_type: action_type5,
+    result: result5
+  }).describe("Setting HVAC to heat mode succeeded."),
+  common_failed_action_attempt.extend({ action_type: action_type5, error: error5 }).describe("Setting HVAC to heat mode failed.")
+]);
+var action_type6 = zod.z.literal("SET_HEAT_COOL");
+var error6 = zod.z.object({
+  type: zod.z.string(),
+  message: zod.z.string()
+});
+var result6 = zod.z.object({});
+var set_heat_cool_action_attempt = zod.z.discriminatedUnion("status", [
+  common_pending_action_attempt.extend({
+    action_type: action_type6
+  }).describe("Setting HVAC to heat-cool mode."),
+  common_succeeded_action_attempt.extend({
+    action_type: action_type6,
+    result: result6
+  }).describe("Setting HVAC to heat-cool mode succeeded."),
+  common_failed_action_attempt.extend({ action_type: action_type6, error: error6 }).describe("Setting heat-cool mode failed.")
+]);
+var action_type7 = zod.z.literal("SET_THERMOSTAT_OFF");
+var error7 = zod.z.object({
+  type: zod.z.string(),
+  message: zod.z.string()
+});
+var result7 = zod.z.object({});
+var set_thermostat_off_action_attempt = zod.z.discriminatedUnion(
+  "status",
+  [
+    common_pending_action_attempt.extend({
+      action_type: action_type7
+    }).describe("Turning HVAC off."),
+    common_succeeded_action_attempt.extend({
+      action_type: action_type7,
+      result: result7
+    }).describe("Turning HVAC off succeeded."),
+    common_failed_action_attempt.extend({ action_type: action_type7, error: error7 }).describe("Turning HVAC off failed.")
+  ]
+);
+var action_type8 = zod.z.literal("UNLOCK_DOOR");
+var error8 = zod.z.object({
+  type: zod.z.string(),
+  message: zod.z.string()
+});
+var result8 = zod.z.object({});
+var unlock_door_action_attempt = zod.z.discriminatedUnion("status", [
+  common_pending_action_attempt.extend({
+    action_type: action_type8
+  }).describe("Unlocking door."),
+  common_succeeded_action_attempt.extend({
+    action_type: action_type8,
+    result: result8
+  }).describe("Unlocking door succeeded."),
+  common_failed_action_attempt.extend({ action_type: action_type8, error: error8 }).describe("Unlocking door failed.")
+]);
+
+// src/lib/seam/connect/models/action-attempts/action-attempt.ts
+var action_attempt = zod.z.union([
+  ...lock_door_action_attempt.options,
+  ...unlock_door_action_attempt.options,
+  ...reset_sandbox_workspace_action_attempt.options,
+  ...set_cool_action_attempt.options,
+  ...set_heat_action_attempt.options,
+  ...set_heat_cool_action_attempt.options,
+  ...set_fan_mode_action_attempt.options,
+  ...set_thermostat_off_action_attempt.options
+]);
+zod.z.record(
+  zod.z.string().max(40),
+  zod.z.union([zod.z.string().max(500), zod.z.boolean(), zod.z.null()])
 ).refine((val) => Object.keys(val).length <= 50, {
   message: "Custom metadata is limited to a maximum of 50 keys"
 });
-var custom_metadata = z10.z.record(
-  z10.z.string(),
-  z10.z.union([z10.z.string(), z10.z.boolean()])
+var custom_metadata = zod.z.record(
+  zod.z.string(),
+  zod.z.union([zod.z.string(), zod.z.boolean()])
 );
 
 // src/lib/seam/connect/models/connect-webviews/connect-webview.ts
-var connect_webview_device_selection_mode = z10.z.enum([
+var connect_webview_device_selection_mode = zod.z.enum([
   "none",
   "single",
   "multiple"
 ]);
-var connect_webview = z10.z.object({
-  connect_webview_id: z10.z.string().uuid(),
-  workspace_id: z10.z.string().uuid(),
-  created_at: z10.z.string().datetime(),
-  connected_account_id: z10.z.string().uuid().nullable(),
-  url: z10.z.string().url(),
+var connect_webview = zod.z.object({
+  connect_webview_id: zod.z.string().uuid(),
+  workspace_id: zod.z.string().uuid(),
+  created_at: zod.z.string().datetime(),
+  connected_account_id: zod.z.string().uuid().nullable(),
+  url: zod.z.string().url(),
   device_selection_mode: connect_webview_device_selection_mode,
   // TODO: Use enum value.
-  accepted_providers: z10.z.array(z10.z.string()),
-  accepted_devices: z10.z.array(z10.z.string()).describe(
+  accepted_providers: zod.z.array(zod.z.string()),
+  accepted_devices: zod.z.array(zod.z.string()).describe(
     `
       ---
       deprecated: Unused. Will be removed.
       ---
       `
   ),
-  any_device_allowed: z10.z.boolean().describe(
+  any_device_allowed: zod.z.boolean().describe(
     `
       ---
       deprecated: Unused. Will be removed.
       ---
       `
   ),
-  any_provider_allowed: z10.z.boolean(),
-  login_successful: z10.z.boolean(),
-  status: z10.z.enum(["pending", "failed", "authorized"]),
-  custom_redirect_url: z10.z.string().url().nullable(),
-  custom_redirect_failure_url: z10.z.string().url().nullable(),
+  any_provider_allowed: zod.z.boolean(),
+  login_successful: zod.z.boolean(),
+  status: zod.z.enum(["pending", "failed", "authorized"]),
+  custom_redirect_url: zod.z.string().url().nullable(),
+  custom_redirect_failure_url: zod.z.string().url().nullable(),
   custom_metadata,
-  automatically_manage_new_devices: z10.z.boolean(),
-  wait_for_device_creation: z10.z.boolean(),
-  authorized_at: z10.z.string().datetime().nullable(),
-  selected_provider: z10.z.string().nullable()
+  automatically_manage_new_devices: zod.z.boolean(),
+  wait_for_device_creation: zod.z.boolean(),
+  authorized_at: zod.z.string().datetime().nullable(),
+  selected_provider: zod.z.string().nullable()
 });
-var common_event = z10__namespace.object({
-  workspace_id: z10__namespace.string().uuid().describe(`
+var common_event = zod.z.object({
+  workspace_id: zod.z.string().uuid().describe(`
     ---
     title: Workspace ID
     ---
     The ID of the workspace.
   `),
-  created_at: z10__namespace.string().datetime().describe(`
+  created_at: zod.z.string().datetime().describe(`
     ---
     title: Created At
     ---
     The time when the event was created.
   `),
-  occurred_at: z10__namespace.string().datetime().describe(`
+  occurred_at: zod.z.string().datetime().describe(`
     ---
     title: Occurred At
     ---
@@ -109,97 +263,97 @@ var common_event = z10__namespace.object({
 
 // src/lib/seam/connect/models/events/access-codes.ts
 var access_code_event = common_event.extend({
-  access_code_id: z10__namespace.string().uuid().describe(`
+  access_code_id: zod.z.string().uuid().describe(`
     ---
     title: Access Code ID
     ---
     The ID of the access code.
   `),
-  device_id: z10__namespace.string().uuid().describe(`
+  device_id: zod.z.string().uuid().describe(`
     ---
     title: Device ID
     ---
     The ID of the device.
   `),
-  connected_account_id: z10__namespace.string().uuid().describe(`
+  connected_account_id: zod.z.string().uuid().describe(`
     ---
     title: Connected Account ID
     ---
     The ID of the connected account.
   `)
 });
-var code = z10__namespace.string().describe(`
+var code = zod.z.string().describe(`
   ---
   title: Access Code
   ---
   The code of the access code.
 `);
 var access_code_created_event = access_code_event.extend({
-  event_type: z10__namespace.literal("access_code.created")
+  event_type: zod.z.literal("access_code.created")
 }).describe("An access code was created.");
 var access_code_changed_event = access_code_event.extend({
-  event_type: z10__namespace.literal("access_code.changed")
+  event_type: zod.z.literal("access_code.changed")
 }).describe("An access code was changed.");
 var access_code_scheduled_on_device_event = access_code_event.extend({
-  event_type: z10__namespace.literal("access_code.scheduled_on_device"),
+  event_type: zod.z.literal("access_code.scheduled_on_device"),
   code
 }).describe("An access code was natively scheduled on a device.");
 var access_code_set_on_device_event = access_code_event.extend({
-  event_type: z10__namespace.literal("access_code.set_on_device"),
+  event_type: zod.z.literal("access_code.set_on_device"),
   code
 }).describe("An access code was set on a device.");
 var access_code_removed_from_device_event = access_code_event.extend({
-  event_type: z10__namespace.literal("access_code.removed_from_device")
+  event_type: zod.z.literal("access_code.removed_from_device")
 }).describe("An access code was removed from a device.");
 var access_code_delay_in_setting_on_device_event = access_code_event.extend({
-  event_type: z10__namespace.literal("access_code.delay_in_setting_on_device")
+  event_type: zod.z.literal("access_code.delay_in_setting_on_device")
 }).describe(
   "There was an unusually long delay in setting an access code on a device."
 );
 var access_code_failed_to_set_on_device_event = access_code_event.extend({
-  event_type: z10__namespace.literal("access_code.failed_to_set_on_device")
+  event_type: zod.z.literal("access_code.failed_to_set_on_device")
 }).describe("An access code failed to be set on a device.");
 var access_code_deleted_event = access_code_event.extend({
-  event_type: z10__namespace.literal("access_code.deleted"),
+  event_type: zod.z.literal("access_code.deleted"),
   code: code.nullable()
 }).describe("An access code was deleted.");
 var access_code_delay_in_removing_from_device_event = access_code_event.extend({
-  event_type: z10__namespace.literal("access_code.delay_in_removing_from_device")
+  event_type: zod.z.literal("access_code.delay_in_removing_from_device")
 }).describe(
   "There was an unusually long delay in removing an access code from a device."
 );
 var access_code_failed_to_remove_from_device_event = access_code_event.extend({
-  event_type: z10__namespace.literal("access_code.failed_to_remove_from_device")
+  event_type: zod.z.literal("access_code.failed_to_remove_from_device")
 }).describe("An access code failed to be removed from a device.");
 var access_code_modified_external_to_seam_event = access_code_event.extend({
-  event_type: z10__namespace.literal("access_code.modified_external_to_seam")
+  event_type: zod.z.literal("access_code.modified_external_to_seam")
 }).describe("An access code was modified external to Seam.");
 var access_code_deleted_external_to_seam_event = access_code_event.extend({
-  event_type: z10__namespace.literal("access_code.deleted_external_to_seam")
+  event_type: zod.z.literal("access_code.deleted_external_to_seam")
 }).describe("An access code was deleted external to Seam.");
 var access_code_backup_access_code_pulled_event = access_code_event.extend({
-  event_type: z10__namespace.literal("access_code.backup_access_code_pulled"),
-  backup_access_code_id: z10__namespace.string()
+  event_type: zod.z.literal("access_code.backup_access_code_pulled"),
+  backup_access_code_id: zod.z.string()
 }).describe(
   "A backup access code was pulled from the backup access code pool and set on a device."
 );
 var unmanaged_access_code_converted_to_managed_event = access_code_event.extend({
-  event_type: z10__namespace.literal("access_code.unmanaged.converted_to_managed")
+  event_type: zod.z.literal("access_code.unmanaged.converted_to_managed")
 }).describe(
   "An unmanaged access code was successfully converted to a managed access code."
 );
 var unmanaged_access_code_failed_to_convert_to_managed_event = access_code_event.extend({
-  event_type: z10__namespace.literal(
+  event_type: zod.z.literal(
     "access_code.unmanaged.failed_to_convert_to_managed"
   )
 }).describe(
   "An unmanaged access code failed to be converted to a managed access code."
 );
 var unmanaged_access_code_created_event = access_code_event.extend({
-  event_type: z10__namespace.literal("access_code.unmanaged.created")
+  event_type: zod.z.literal("access_code.unmanaged.created")
 }).describe("An unmanaged access code was created on a device.");
 var unmanaged_access_code_removed_event = access_code_event.extend({
-  event_type: z10__namespace.literal("access_code.unmanaged.removed")
+  event_type: zod.z.literal("access_code.unmanaged.removed")
 }).describe("An unmanaged access code was removed from a device.");
 var access_code_events = [
   access_code_created_event,
@@ -221,13 +375,13 @@ var access_code_events = [
   unmanaged_access_code_removed_event
 ];
 var common_acs_event = common_event.extend({
-  connected_account_id: z10__namespace.string().uuid().describe(`
+  connected_account_id: zod.z.string().uuid().describe(`
     ---
     title: Connected Account ID
     ---
     ID of the connected account.
   `),
-  acs_system_id: z10__namespace.string().uuid().describe(`
+  acs_system_id: zod.z.string().uuid().describe(`
     ---
     title: ACS System ID
     ---
@@ -237,17 +391,17 @@ var common_acs_event = common_event.extend({
 
 // src/lib/seam/connect/models/events/acs/credentials.ts
 var acs_credential_event = common_acs_event.extend({
-  acs_credential_id: z10__namespace.string().uuid()
+  acs_credential_id: zod.z.string().uuid()
 });
 var acs_credential_deleted_event = acs_credential_event.extend({
-  event_type: z10__namespace.literal("acs_credential.deleted")
+  event_type: zod.z.literal("acs_credential.deleted")
 }).describe("An ACS credential was deleted.");
 var acs_credential_events = [acs_credential_deleted_event];
 var acs_user_event = common_acs_event.extend({
-  acs_user_id: z10__namespace.string().uuid()
+  acs_user_id: zod.z.string().uuid()
 });
 var acs_user_deleted_event = acs_user_event.extend({
-  event_type: z10__namespace.literal("acs_user.deleted")
+  event_type: zod.z.literal("acs_user.deleted")
 }).describe("An ACS user was deleted.");
 var acs_user_events = [acs_user_deleted_event];
 
@@ -257,7 +411,7 @@ var acs_events = [
   ...acs_user_events
 ];
 var client_session_event = common_event.extend({
-  client_session_id: z10__namespace.string().uuid().describe(`
+  client_session_id: zod.z.string().uuid().describe(`
     ---
     title: Client Session ID
     ---
@@ -265,50 +419,50 @@ var client_session_event = common_event.extend({
   `)
 });
 var client_session_deleted_event = client_session_event.extend({
-  event_type: z10__namespace.literal("client_session.deleted")
+  event_type: zod.z.literal("client_session.deleted")
 }).describe("A client session was deleted.");
 var client_session_events = [client_session_deleted_event];
 var connected_account_event = common_event.extend({
-  connected_account_id: z10__namespace.string().uuid().describe(`
+  connected_account_id: zod.z.string().uuid().describe(`
     ---
     title: Connected Account ID
     ---
     ID of the connected account.
   `)
 });
-var connect_webview_id = z10__namespace.string().uuid().describe(`
+var connect_webview_id = zod.z.string().uuid().describe(`
   ---
   title: Connect Webview ID
   ---
   ID of the connect webview.
 `);
 var connected_account_connected_event = connected_account_event.extend({
-  event_type: z10__namespace.literal("connected_account.connected"),
+  event_type: zod.z.literal("connected_account.connected"),
   connect_webview_id
 }).describe(
   "A connected account was connected for the first time, was reconnected after being disconnected."
 );
 var connected_account_created_event = connected_account_event.extend({
-  event_type: z10__namespace.literal("connected_account.created"),
+  event_type: zod.z.literal("connected_account.created"),
   connect_webview_id
 }).describe("A connected account was created.");
 var connected_account_successful_login_event = connected_account_event.extend({
-  event_type: z10__namespace.literal("connected_account.successful_login"),
+  event_type: zod.z.literal("connected_account.successful_login"),
   connect_webview_id
 }).describe("A connected account had a successful connect webview login.");
 var connected_account_disconnected_event = connected_account_event.extend({
-  event_type: z10__namespace.literal("connected_account.disconnected")
+  event_type: zod.z.literal("connected_account.disconnected")
 }).describe("A connected account was disconnected.");
 var connected_account_completed_first_sync_event = connected_account_event.extend({
-  event_type: z10__namespace.literal("connected_account.completed_first_sync")
+  event_type: zod.z.literal("connected_account.completed_first_sync")
 }).describe(
   "A connected account completed the first sync with Seam and devices are now available."
 );
 var connected_account_deleted_event = connected_account_event.extend({
-  event_type: z10__namespace.literal("connected_account.deleted")
+  event_type: zod.z.literal("connected_account.deleted")
 }).describe("A connected account was deleted.");
 var connected_account_completed_first_sync_after_reconnection_event = connected_account_event.extend({
-  event_type: z10__namespace.literal(
+  event_type: zod.z.literal(
     "connected_account.completed_first_sync_after_reconnection"
   )
 }).describe(
@@ -324,32 +478,32 @@ var connected_account_events = [
   connected_account_completed_first_sync_after_reconnection_event
 ];
 var device_event = common_event.extend({
-  device_id: z10__namespace.string().uuid().describe(`
+  device_id: zod.z.string().uuid().describe(`
     ---
     title: Device ID
     ---
     ID of the device.
   `),
-  connected_account_id: z10__namespace.string().uuid().describe(`
+  connected_account_id: zod.z.string().uuid().describe(`
     ---
     title: Connected Account ID
     ---
     ID of the connected account.
   `)
 });
-var battery_level = z10__namespace.number().min(0).max(1).describe(`
+var battery_level = zod.z.number().min(0).max(1).describe(`
   ---
   title: Battery Level
   ---
   Fractional number 0 to 1.0 indicating amount of battery in device, as reported by device.
 `);
-var device_battery_status = z10__namespace.enum(["critical", "low", "good", "full"]).describe(`
+var device_battery_status = zod.z.enum(["critical", "low", "good", "full"]).describe(`
   ---
   title: Battery Status
   ---
   Enum representing the battery status calculated from numeric battery_level value, one of 'critical' | 'low' | 'good' | 'full'
 `);
-var disconnection_error_code = z10__namespace.enum([
+var disconnection_error_code = zod.z.enum([
   "account_disconnected",
   "hub_disconnected",
   "device_disconnected"
@@ -359,108 +513,108 @@ var disconnection_error_code = z10__namespace.enum([
   ---
   The error code associated with the event, if any.
 `);
-var lock_method = z10__namespace.enum(["keycode", "manual", "unknown", "seamapi"]).describe(`
+var lock_method = zod.z.enum(["keycode", "manual", "unknown", "seamapi"]).describe(`
   ---
   title: Lock Lock/Unlock Method
   ---
   Method by which a lock device was locked or unlocked. When the method is \`keycode\`, the \`access_code_id\` will reference the Seam access code which was used, if reported by the device.
 `);
 var device_connected_event = device_event.extend({
-  event_type: z10__namespace.literal("device.connected")
+  event_type: zod.z.literal("device.connected")
 }).describe("A new device was connected to Seam.");
 var device_converted_to_unmanaged_event = device_event.extend({
-  event_type: z10__namespace.literal("device.converted_to_unmanaged")
+  event_type: zod.z.literal("device.converted_to_unmanaged")
 }).describe(
   "An unmanaged device was successfully converted to a managed device."
 );
 var unmanaged_device_converted_to_managed_event = device_event.extend({
-  event_type: z10__namespace.literal("device.unmanaged.converted_to_managed")
+  event_type: zod.z.literal("device.unmanaged.converted_to_managed")
 }).describe(
   "A managed device was successfully converted to an unmanaged device."
 );
 var unmanaged_device_connected_event = device_event.extend({
-  event_type: z10__namespace.literal("device.unmanaged.connected")
+  event_type: zod.z.literal("device.unmanaged.connected")
 }).describe("An unmanaged device was connected to Seam");
 var device_disconnected_event = device_event.extend({
-  event_type: z10__namespace.literal("device.disconnected"),
+  event_type: zod.z.literal("device.disconnected"),
   error_code: disconnection_error_code
 }).describe("A device was disconnected");
 var unmanaged_device_disconnected_event = device_event.extend({
-  event_type: z10__namespace.literal("device.unmanaged.disconnected"),
+  event_type: zod.z.literal("device.unmanaged.disconnected"),
   error_code: disconnection_error_code
 }).describe("An unmanaged device was disconnected");
 var device_tampered_event = device_event.extend({
-  event_type: z10__namespace.literal("device.tampered")
+  event_type: zod.z.literal("device.tampered")
 }).describe(
   "A device detected that it was tampered with, e.g., opened or moved."
 );
 var device_low_battery_event = device_event.extend({
-  event_type: z10__namespace.literal("device.low_battery"),
+  event_type: zod.z.literal("device.low_battery"),
   battery_level
 }).describe("A device battery level dropped below the low threshold.");
 var device_battery_status_changed_event = device_event.extend({
-  event_type: z10__namespace.literal("device.battery_status_changed"),
+  event_type: zod.z.literal("device.battery_status_changed"),
   battery_status: device_battery_status,
   battery_level
 }).describe(
   "A device battery status changed since the last battery status changed event."
 );
 var device_removed_event = device_event.extend({
-  event_type: z10__namespace.literal("device.removed")
+  event_type: zod.z.literal("device.removed")
 }).describe("A device was removed externally from the connected account.");
 var device_deleted_event = device_event.extend({
-  event_type: z10__namespace.literal("device.deleted")
+  event_type: zod.z.literal("device.deleted")
 }).describe("A device was deleted.");
 var device_third_party_integration_detected_event = device_event.extend({
-  event_type: z10__namespace.literal("device.third_party_integration_detected")
+  event_type: zod.z.literal("device.third_party_integration_detected")
 }).describe(
   "Seam detected a device is using a third party integration that will interfere with Seam device management."
 );
 var device_third_party_integration_no_longer_detected_event = device_event.extend({
-  event_type: z10__namespace.literal(
+  event_type: zod.z.literal(
     "device.third_party_integration_no_longer_detected"
   )
 }).describe(
   "Seam detected a device is no longer using a third party integration that was interfering with Seam device management."
 );
 var device_salto_privacy_mode_activated_event = device_event.extend({
-  event_type: z10__namespace.literal("device.salto.privacy_mode_activated")
+  event_type: zod.z.literal("device.salto.privacy_mode_activated")
 }).describe("A Salto device activated privacy mode.");
 var device_salto_privacy_mode_deactivated_event = device_event.extend({
-  event_type: z10__namespace.literal("device.salto.privacy_mode_deactivated")
+  event_type: zod.z.literal("device.salto.privacy_mode_deactivated")
 }).describe("A Salto device deactivated privacy mode.");
 var device_connection_became_flaky_event = device_event.extend({
-  event_type: z10__namespace.literal("device.connection_became_flaky")
+  event_type: zod.z.literal("device.connection_became_flaky")
 }).describe("Seam detected a flaky device connection.");
 var device_connection_stabilized_event = device_event.extend({
-  event_type: z10__namespace.literal("device.connection_stabilized")
+  event_type: zod.z.literal("device.connection_stabilized")
 }).describe("Seam detected a previously flaky device connection stabilized.");
 var device_error_subscription_required_event = device_event.extend({
-  event_type: z10__namespace.literal("device.error.subscription_required")
+  event_type: zod.z.literal("device.error.subscription_required")
 }).describe(
   "A third party subscription is required to use all device features."
 );
 var device_error_subscription_required_resolved_event = device_event.extend({
-  event_type: z10__namespace.literal("device.error.subscription_required.resolved")
+  event_type: zod.z.literal("device.error.subscription_required.resolved")
 }).describe(
   "A third party subscription is active or no longer-required to use all device features."
 );
 var device_accessory_keypad_connected_event = device_event.extend({
-  event_type: z10__namespace.literal("device.accessory_keypad_connected")
+  event_type: zod.z.literal("device.accessory_keypad_connected")
 }).describe("A accessory keypad was connected to a device.");
 var device_accessory_keypad_disconnected_event = device_event.extend({
-  event_type: z10__namespace.literal("device.accessory_keypad_disconnected")
+  event_type: zod.z.literal("device.accessory_keypad_disconnected")
 }).describe("A accessory keypad was disconnected to a device.");
 var noise_sensor_noise_threshold_triggered_event = device_event.extend({
-  event_type: z10__namespace.literal("noise_sensor.noise_threshold_triggered"),
+  event_type: zod.z.literal("noise_sensor.noise_threshold_triggered"),
   // TODO: import from ../devices
-  noiseaware_metadata: z10__namespace.record(z10__namespace.unknown()).optional().describe(`
+  noiseaware_metadata: zod.z.record(zod.z.unknown()).optional().describe(`
       ---
       title: Noiseaware Metadata
       ---
       Metadata from the Noiseaware API.
     `),
-  minut_metadata: z10__namespace.record(z10__namespace.unknown()).optional().describe(`
+  minut_metadata: zod.z.record(zod.z.unknown()).optional().describe(`
       ---
       title: Minut Metadata
       ---
@@ -470,15 +624,15 @@ var noise_sensor_noise_threshold_triggered_event = device_event.extend({
   "Extended periods of noise or noise exceeding a threshold was detected."
 );
 var lock_locked_event = device_event.extend({
-  event_type: z10__namespace.literal("lock.locked"),
-  access_code_id: z10__namespace.string().uuid().optional(),
-  action_attempt_id: z10__namespace.string().uuid().optional(),
+  event_type: zod.z.literal("lock.locked"),
+  access_code_id: zod.z.string().uuid().optional(),
+  action_attempt_id: zod.z.string().uuid().optional(),
   method: lock_method
 }).describe("A lock was locked.");
 var lock_unlocked_event = device_event.extend({
-  event_type: z10__namespace.literal("lock.unlocked"),
-  access_code_id: z10__namespace.string().uuid().optional(),
-  action_attempt_id: z10__namespace.string().uuid().optional(),
+  event_type: zod.z.literal("lock.unlocked"),
+  access_code_id: zod.z.string().uuid().optional(),
+  action_attempt_id: zod.z.string().uuid().optional(),
   method: lock_method
 }).describe("A lock was unlocked.");
 var device_events = [
@@ -508,7 +662,7 @@ var device_events = [
   lock_unlocked_event
 ];
 var enrollment_automation_event = common_event.extend({
-  enrollment_automation_id: z10__namespace.string().uuid().describe(`
+  enrollment_automation_id: zod.z.string().uuid().describe(`
     ---
     title: Enrollment Automation ID
     ---
@@ -516,13 +670,13 @@ var enrollment_automation_event = common_event.extend({
   `)
 });
 var enrollment_automation_deleted_event = enrollment_automation_event.extend({
-  event_type: z10__namespace.literal("enrollment_automation.deleted")
+  event_type: zod.z.literal("enrollment_automation.deleted")
 }).describe("An enrollment automation was deleted.");
 var enrollment_automation_events = [
   enrollment_automation_deleted_event
 ];
 var phone_event = common_event.extend({
-  device_id: z10__namespace.string().uuid().describe(`
+  device_id: zod.z.string().uuid().describe(`
     ---
     title: Device ID
     ---
@@ -530,12 +684,12 @@ var phone_event = common_event.extend({
   `)
 });
 var phone_deactivated_event = phone_event.extend({
-  event_type: z10__namespace.literal("phone.deactivated")
+  event_type: zod.z.literal("phone.deactivated")
 }).describe("A phone device was deactivated.");
 var phone_events = [phone_deactivated_event];
 
 // src/lib/seam/connect/models/events/seam-event.ts
-var seam_event = z10__namespace.discriminatedUnion("event_type", [
+var seam_event = zod.z.discriminatedUnion("event_type", [
   ...access_code_events,
   ...acs_events,
   ...client_session_events,
@@ -925,6 +1079,17 @@ var openapi_default = {
           can_remove_acs_users_from_acs_access_groups: { type: "boolean" },
           connected_account_ids: { items: { type: "string" }, type: "array" },
           created_at: { format: "date-time", type: "string" },
+          errors: {
+            items: {
+              properties: {
+                error_code: { type: "string" },
+                message: { type: "string" }
+              },
+              required: ["error_code", "message"],
+              type: "object"
+            },
+            type: "array"
+          },
           external_type: {
             enum: [
               "pti_site",
@@ -960,6 +1125,17 @@ var openapi_default = {
             description: "\n      ---\n      deprecated: use external_type_display_name\n      ---\n      ",
             type: "string"
           },
+          warnings: {
+            items: {
+              properties: {
+                message: { type: "string" },
+                warning_code: { type: "string" }
+              },
+              required: ["warning_code", "message"],
+              type: "object"
+            },
+            type: "array"
+          },
           workspace_id: { format: "uuid", type: "string" }
         },
         required: [
@@ -969,7 +1145,9 @@ var openapi_default = {
           "workspace_id",
           "connected_account_ids",
           "image_url",
-          "image_alt_text"
+          "image_alt_text",
+          "errors",
+          "warnings"
         ],
         type: "object"
       },
@@ -1025,40 +1203,580 @@ var openapi_default = {
         type: "object"
       },
       action_attempt: {
-        discriminator: { propertyName: "status" },
         oneOf: [
           {
+            description: "Locking door.",
+            properties: {
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: { enum: ["LOCK_DOOR"], type: "string" },
+              error: { format: "null", nullable: true, type: "string" },
+              result: { format: "null", nullable: true, type: "string" },
+              status: { enum: ["pending"], type: "string" }
+            },
+            required: [
+              "action_attempt_id",
+              "status",
+              "result",
+              "error",
+              "action_type"
+            ],
+            type: "object"
+          },
+          {
+            description: "Locking door succeeded.",
+            properties: {
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: { enum: ["LOCK_DOOR"], type: "string" },
+              error: { format: "null", nullable: true, type: "string" },
+              result: { properties: {}, type: "object" },
+              status: { enum: ["success"], type: "string" }
+            },
+            required: [
+              "action_attempt_id",
+              "status",
+              "error",
+              "action_type",
+              "result"
+            ],
+            type: "object"
+          },
+          {
+            description: "Locking door failed.",
+            properties: {
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: { enum: ["LOCK_DOOR"], type: "string" },
+              error: {
+                properties: {
+                  message: { type: "string" },
+                  type: { type: "string" }
+                },
+                required: ["type", "message"],
+                type: "object"
+              },
+              result: { format: "null", nullable: true, type: "string" },
+              status: { enum: ["error"], type: "string" }
+            },
+            required: [
+              "action_attempt_id",
+              "status",
+              "result",
+              "action_type",
+              "error"
+            ],
+            type: "object"
+          },
+          {
+            description: "Unlocking door.",
+            properties: {
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: { enum: ["UNLOCK_DOOR"], type: "string" },
+              error: { format: "null", nullable: true, type: "string" },
+              result: { format: "null", nullable: true, type: "string" },
+              status: { enum: ["pending"], type: "string" }
+            },
+            required: [
+              "action_attempt_id",
+              "status",
+              "result",
+              "error",
+              "action_type"
+            ],
+            type: "object"
+          },
+          {
+            description: "Unlocking door succeeded.",
+            properties: {
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: { enum: ["UNLOCK_DOOR"], type: "string" },
+              error: { format: "null", nullable: true, type: "string" },
+              result: { properties: {}, type: "object" },
+              status: { enum: ["success"], type: "string" }
+            },
+            required: [
+              "action_attempt_id",
+              "status",
+              "error",
+              "action_type",
+              "result"
+            ],
+            type: "object"
+          },
+          {
+            description: "Unlocking door failed.",
+            properties: {
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: { enum: ["UNLOCK_DOOR"], type: "string" },
+              error: {
+                properties: {
+                  message: { type: "string" },
+                  type: { type: "string" }
+                },
+                required: ["type", "message"],
+                type: "object"
+              },
+              result: { format: "null", nullable: true, type: "string" },
+              status: { enum: ["error"], type: "string" }
+            },
+            required: [
+              "action_attempt_id",
+              "status",
+              "result",
+              "action_type",
+              "error"
+            ],
+            type: "object"
+          },
+          {
+            description: "Resetting sandbox workspace.",
+            properties: {
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: {
+                enum: ["RESET_SANDBOX_WORKSPACE"],
+                type: "string"
+              },
+              error: { format: "null", nullable: true, type: "string" },
+              result: { format: "null", nullable: true, type: "string" },
+              status: { enum: ["pending"], type: "string" }
+            },
+            required: [
+              "action_attempt_id",
+              "status",
+              "result",
+              "error",
+              "action_type"
+            ],
+            type: "object"
+          },
+          {
+            description: "Resetting sandbox workspace succeeded.",
+            properties: {
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: {
+                enum: ["RESET_SANDBOX_WORKSPACE"],
+                type: "string"
+              },
+              error: { format: "null", nullable: true, type: "string" },
+              result: { properties: {}, type: "object" },
+              status: { enum: ["success"], type: "string" }
+            },
+            required: [
+              "action_attempt_id",
+              "status",
+              "error",
+              "action_type",
+              "result"
+            ],
+            type: "object"
+          },
+          {
+            description: "Resetting sandbox workspace failed.",
+            properties: {
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: {
+                enum: ["RESET_SANDBOX_WORKSPACE"],
+                type: "string"
+              },
+              error: {
+                properties: {
+                  message: { type: "string" },
+                  type: { type: "string" }
+                },
+                required: ["type", "message"],
+                type: "object"
+              },
+              result: { format: "null", nullable: true, type: "string" },
+              status: { enum: ["error"], type: "string" }
+            },
+            required: [
+              "action_attempt_id",
+              "status",
+              "result",
+              "action_type",
+              "error"
+            ],
+            type: "object"
+          },
+          {
+            description: "Setting HVAC to cool.",
+            properties: {
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: { enum: ["SET_COOL"], type: "string" },
+              error: { format: "null", nullable: true, type: "string" },
+              result: { format: "null", nullable: true, type: "string" },
+              status: { enum: ["pending"], type: "string" }
+            },
+            required: [
+              "action_attempt_id",
+              "status",
+              "result",
+              "error",
+              "action_type"
+            ],
+            type: "object"
+          },
+          {
+            description: "Setting HVAC to cool succeeded.",
+            properties: {
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: { enum: ["SET_COOL"], type: "string" },
+              error: { format: "null", nullable: true, type: "string" },
+              result: { properties: {}, type: "object" },
+              status: { enum: ["success"], type: "string" }
+            },
+            required: [
+              "action_attempt_id",
+              "status",
+              "error",
+              "action_type",
+              "result"
+            ],
+            type: "object"
+          },
+          {
+            description: "Setting HVAC to cool failed.",
+            properties: {
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: { enum: ["SET_COOL"], type: "string" },
+              error: {
+                properties: {
+                  message: { type: "string" },
+                  type: { type: "string" }
+                },
+                required: ["type", "message"],
+                type: "object"
+              },
+              result: { format: "null", nullable: true, type: "string" },
+              status: { enum: ["error"], type: "string" }
+            },
+            required: [
+              "action_attempt_id",
+              "status",
+              "result",
+              "action_type",
+              "error"
+            ],
+            type: "object"
+          },
+          {
+            description: "Setting HVAC to heat mode.",
+            properties: {
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: { enum: ["SET_HEAT"], type: "string" },
+              error: { format: "null", nullable: true, type: "string" },
+              result: { format: "null", nullable: true, type: "string" },
+              status: { enum: ["pending"], type: "string" }
+            },
+            required: [
+              "action_attempt_id",
+              "status",
+              "result",
+              "error",
+              "action_type"
+            ],
+            type: "object"
+          },
+          {
+            description: "Setting HVAC to heat mode succeeded.",
+            properties: {
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: { enum: ["SET_HEAT"], type: "string" },
+              error: { format: "null", nullable: true, type: "string" },
+              result: { properties: {}, type: "object" },
+              status: { enum: ["success"], type: "string" }
+            },
+            required: [
+              "action_attempt_id",
+              "status",
+              "error",
+              "action_type",
+              "result"
+            ],
+            type: "object"
+          },
+          {
+            description: "Setting HVAC to heat mode failed.",
+            properties: {
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: { enum: ["SET_HEAT"], type: "string" },
+              error: {
+                properties: {
+                  message: { type: "string" },
+                  type: { type: "string" }
+                },
+                required: ["type", "message"],
+                type: "object"
+              },
+              result: { format: "null", nullable: true, type: "string" },
+              status: { enum: ["error"], type: "string" }
+            },
+            required: [
+              "action_attempt_id",
+              "status",
+              "result",
+              "action_type",
+              "error"
+            ],
+            type: "object"
+          },
+          {
+            description: "Setting HVAC to heat-cool mode.",
+            properties: {
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: { enum: ["SET_HEAT_COOL"], type: "string" },
+              error: { format: "null", nullable: true, type: "string" },
+              result: { format: "null", nullable: true, type: "string" },
+              status: { enum: ["pending"], type: "string" }
+            },
+            required: [
+              "action_attempt_id",
+              "status",
+              "result",
+              "error",
+              "action_type"
+            ],
+            type: "object"
+          },
+          {
+            description: "Setting HVAC to heat-cool mode succeeded.",
+            properties: {
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: { enum: ["SET_HEAT_COOL"], type: "string" },
+              error: { format: "null", nullable: true, type: "string" },
+              result: { properties: {}, type: "object" },
+              status: { enum: ["success"], type: "string" }
+            },
+            required: [
+              "action_attempt_id",
+              "status",
+              "error",
+              "action_type",
+              "result"
+            ],
+            type: "object"
+          },
+          {
+            description: "Setting heat-cool mode failed.",
+            properties: {
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: { enum: ["SET_HEAT_COOL"], type: "string" },
+              error: {
+                properties: {
+                  message: { type: "string" },
+                  type: { type: "string" }
+                },
+                required: ["type", "message"],
+                type: "object"
+              },
+              result: { format: "null", nullable: true, type: "string" },
+              status: { enum: ["error"], type: "string" }
+            },
+            required: [
+              "action_attempt_id",
+              "status",
+              "result",
+              "action_type",
+              "error"
+            ],
+            type: "object"
+          },
+          {
+            description: "Setting fan mode.",
             properties: {
-              action_attempt_id: { format: "uuid", type: "string" },
-              action_type: { type: "string" },
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: { enum: ["SET_FAN_MODE"], type: "string" },
               error: { format: "null", nullable: true, type: "string" },
-              result: { nullable: true },
-              status: { enum: ["success"], type: "string" }
+              result: { format: "null", nullable: true, type: "string" },
+              status: { enum: ["pending"], type: "string" }
             },
-            required: ["status", "action_type", "action_attempt_id", "error"],
+            required: [
+              "action_attempt_id",
+              "status",
+              "result",
+              "error",
+              "action_type"
+            ],
             type: "object"
           },
           {
+            description: "Setting fan mode succeeded.",
             properties: {
-              action_attempt_id: { format: "uuid", type: "string" },
-              action_type: { type: "string" },
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: { enum: ["SET_FAN_MODE"], type: "string" },
               error: { format: "null", nullable: true, type: "string" },
-              result: { format: "null", nullable: true, type: "string" },
-              status: { enum: ["pending"], type: "string" }
+              result: { properties: {}, type: "object" },
+              status: { enum: ["success"], type: "string" }
             },
             required: [
+              "action_attempt_id",
               "status",
+              "error",
               "action_type",
+              "result"
+            ],
+            type: "object"
+          },
+          {
+            description: "Setting fan mode failed.",
+            properties: {
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: { enum: ["SET_FAN_MODE"], type: "string" },
+              error: {
+                properties: {
+                  message: { type: "string" },
+                  type: { type: "string" }
+                },
+                required: ["type", "message"],
+                type: "object"
+              },
+              result: { format: "null", nullable: true, type: "string" },
+              status: { enum: ["error"], type: "string" }
+            },
+            required: [
               "action_attempt_id",
+              "status",
               "result",
+              "action_type",
               "error"
             ],
             type: "object"
           },
           {
+            description: "Turning HVAC off.",
+            properties: {
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: { enum: ["SET_THERMOSTAT_OFF"], type: "string" },
+              error: { format: "null", nullable: true, type: "string" },
+              result: { format: "null", nullable: true, type: "string" },
+              status: { enum: ["pending"], type: "string" }
+            },
+            required: [
+              "action_attempt_id",
+              "status",
+              "result",
+              "error",
+              "action_type"
+            ],
+            type: "object"
+          },
+          {
+            description: "Turning HVAC off succeeded.",
+            properties: {
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: { enum: ["SET_THERMOSTAT_OFF"], type: "string" },
+              error: { format: "null", nullable: true, type: "string" },
+              result: { properties: {}, type: "object" },
+              status: { enum: ["success"], type: "string" }
+            },
+            required: [
+              "action_attempt_id",
+              "status",
+              "error",
+              "action_type",
+              "result"
+            ],
+            type: "object"
+          },
+          {
+            description: "Turning HVAC off failed.",
             properties: {
-              action_attempt_id: { format: "uuid", type: "string" },
-              action_type: { type: "string" },
+              action_attempt_id: {
+                description: "\n    ---\n    title: Action Attempt ID\n    ---\n    The ID of the action attempt.\n  ",
+                format: "uuid",
+                type: "string"
+              },
+              action_type: { enum: ["SET_THERMOSTAT_OFF"], type: "string" },
               error: {
                 properties: {
                   message: { type: "string" },
@@ -1071,10 +1789,10 @@ var openapi_default = {
               status: { enum: ["error"], type: "string" }
             },
             required: [
-              "status",
-              "action_type",
               "action_attempt_id",
+              "status",
               "result",
+              "action_type",
               "error"
             ],
             type: "object"
@@ -1470,7 +2188,7 @@ var openapi_default = {
                           model: {
                             properties: {
                               accessory_keypad_supported: {
-                                description: "Indicates whether the device supports an accessory keypad.",
+                                description: "\n      ---\n      deprecated: use device.properties.model.can_connect_accessory_keypad\n      ---\n      ",
                                 type: "boolean"
                               },
                               can_connect_accessory_keypad: {
@@ -1529,7 +2247,7 @@ var openapi_default = {
                             type: "string"
                           },
                           supports_accessory_keypad: {
-                            description: "\n      ---\n      deprecated: use model.accessory_keypad_supported\n      ---\n      ",
+                            description: "\n      ---\n      deprecated: use device.properties.model.can_connect_accessory_keypad\n      ---\n      ",
                             type: "boolean"
                           },
                           supports_offline_access_codes: {
@@ -3012,7 +3730,7 @@ var openapi_default = {
               model: {
                 properties: {
                   accessory_keypad_supported: {
-                    description: "Indicates whether the device supports an accessory keypad.",
+                    description: "\n      ---\n      deprecated: use device.properties.model.can_connect_accessory_keypad\n      ---\n      ",
                     type: "boolean"
                   },
                   can_connect_accessory_keypad: {
@@ -3248,7 +3966,91 @@ var openapi_default = {
                   properties: {
                     access_code: { $ref: "#/components/schemas/access_code" },
                     action_attempt: {
-                      $ref: "#/components/schemas/action_attempt"
+                      discriminator: { propertyName: "status" },
+                      oneOf: [
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: { nullable: true },
+                            status: { enum: ["success"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["pending"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              properties: {
+                                message: { type: "string" },
+                                type: { type: "string" }
+                              },
+                              required: ["type", "message"],
+                              type: "object"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["error"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        }
+                      ]
                     },
                     ok: { type: "boolean" }
                   },
@@ -3466,7 +4268,91 @@ var openapi_default = {
                 schema: {
                   properties: {
                     action_attempt: {
-                      $ref: "#/components/schemas/action_attempt"
+                      discriminator: { propertyName: "status" },
+                      oneOf: [
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: { nullable: true },
+                            status: { enum: ["success"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["pending"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              properties: {
+                                message: { type: "string" },
+                                type: { type: "string" }
+                              },
+                              required: ["type", "message"],
+                              type: "object"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["error"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        }
+                      ]
                     },
                     ok: { type: "boolean" }
                   },
@@ -3868,7 +4754,91 @@ var openapi_default = {
                 schema: {
                   properties: {
                     action_attempt: {
-                      $ref: "#/components/schemas/action_attempt"
+                      discriminator: { propertyName: "status" },
+                      oneOf: [
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: { nullable: true },
+                            status: { enum: ["success"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["pending"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              properties: {
+                                message: { type: "string" },
+                                type: { type: "string" }
+                              },
+                              required: ["type", "message"],
+                              type: "object"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["error"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        }
+                      ]
                     },
                     ok: { type: "boolean" }
                   },
@@ -4144,7 +5114,91 @@ var openapi_default = {
                 schema: {
                   properties: {
                     action_attempt: {
-                      $ref: "#/components/schemas/action_attempt"
+                      discriminator: { propertyName: "status" },
+                      oneOf: [
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: { nullable: true },
+                            status: { enum: ["success"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["pending"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              properties: {
+                                message: { type: "string" },
+                                type: { type: "string" }
+                              },
+                              required: ["type", "message"],
+                              type: "object"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["error"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        }
+                      ]
                     },
                     ok: { type: "boolean" }
                   },
@@ -4219,7 +5273,91 @@ var openapi_default = {
                 schema: {
                   properties: {
                     action_attempt: {
-                      $ref: "#/components/schemas/action_attempt"
+                      discriminator: { propertyName: "status" },
+                      oneOf: [
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: { nullable: true },
+                            status: { enum: ["success"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["pending"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              properties: {
+                                message: { type: "string" },
+                                type: { type: "string" }
+                              },
+                              required: ["type", "message"],
+                              type: "object"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["error"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        }
+                      ]
                     },
                     ok: { type: "boolean" }
                   },
@@ -4295,7 +5433,91 @@ var openapi_default = {
                 schema: {
                   properties: {
                     action_attempt: {
-                      $ref: "#/components/schemas/action_attempt"
+                      discriminator: { propertyName: "status" },
+                      oneOf: [
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: { nullable: true },
+                            status: { enum: ["success"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["pending"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              properties: {
+                                message: { type: "string" },
+                                type: { type: "string" }
+                              },
+                              required: ["type", "message"],
+                              type: "object"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["error"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        }
+                      ]
                     },
                     ok: { type: "boolean" }
                   },
@@ -6324,7 +7546,91 @@ var openapi_default = {
                 schema: {
                   properties: {
                     action_attempt: {
-                      $ref: "#/components/schemas/action_attempt"
+                      discriminator: { propertyName: "status" },
+                      oneOf: [
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: { nullable: true },
+                            status: { enum: ["success"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["pending"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              properties: {
+                                message: { type: "string" },
+                                type: { type: "string" }
+                              },
+                              required: ["type", "message"],
+                              type: "object"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["error"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        }
+                      ]
                     },
                     ok: { type: "boolean" }
                   },
@@ -6377,7 +7683,93 @@ var openapi_default = {
                 schema: {
                   properties: {
                     action_attempts: {
-                      items: { $ref: "#/components/schemas/action_attempt" },
+                      items: {
+                        discriminator: { propertyName: "status" },
+                        oneOf: [
+                          {
+                            properties: {
+                              action_attempt_id: {
+                                format: "uuid",
+                                type: "string"
+                              },
+                              action_type: { type: "string" },
+                              error: {
+                                format: "null",
+                                nullable: true,
+                                type: "string"
+                              },
+                              result: { nullable: true },
+                              status: { enum: ["success"], type: "string" }
+                            },
+                            required: [
+                              "status",
+                              "action_type",
+                              "action_attempt_id",
+                              "error"
+                            ],
+                            type: "object"
+                          },
+                          {
+                            properties: {
+                              action_attempt_id: {
+                                format: "uuid",
+                                type: "string"
+                              },
+                              action_type: { type: "string" },
+                              error: {
+                                format: "null",
+                                nullable: true,
+                                type: "string"
+                              },
+                              result: {
+                                format: "null",
+                                nullable: true,
+                                type: "string"
+                              },
+                              status: { enum: ["pending"], type: "string" }
+                            },
+                            required: [
+                              "status",
+                              "action_type",
+                              "action_attempt_id",
+                              "result",
+                              "error"
+                            ],
+                            type: "object"
+                          },
+                          {
+                            properties: {
+                              action_attempt_id: {
+                                format: "uuid",
+                                type: "string"
+                              },
+                              action_type: { type: "string" },
+                              error: {
+                                properties: {
+                                  message: { type: "string" },
+                                  type: { type: "string" }
+                                },
+                                required: ["type", "message"],
+                                type: "object"
+                              },
+                              result: {
+                                format: "null",
+                                nullable: true,
+                                type: "string"
+                              },
+                              status: { enum: ["error"], type: "string" }
+                            },
+                            required: [
+                              "status",
+                              "action_type",
+                              "action_attempt_id",
+                              "result",
+                              "error"
+                            ],
+                            type: "object"
+                          }
+                        ]
+                      },
                       type: "array"
                     },
                     ok: { type: "boolean" }
@@ -9126,7 +10518,91 @@ var openapi_default = {
                 schema: {
                   properties: {
                     action_attempt: {
-                      $ref: "#/components/schemas/action_attempt"
+                      discriminator: { propertyName: "status" },
+                      oneOf: [
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: { nullable: true },
+                            status: { enum: ["success"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["pending"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              properties: {
+                                message: { type: "string" },
+                                type: { type: "string" }
+                              },
+                              required: ["type", "message"],
+                              type: "object"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["error"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        }
+                      ]
                     },
                     noise_threshold: {
                       $ref: "#/components/schemas/noise_threshold"
@@ -9180,7 +10656,91 @@ var openapi_default = {
                 schema: {
                   properties: {
                     action_attempt: {
-                      $ref: "#/components/schemas/action_attempt"
+                      discriminator: { propertyName: "status" },
+                      oneOf: [
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: { nullable: true },
+                            status: { enum: ["success"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["pending"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              properties: {
+                                message: { type: "string" },
+                                type: { type: "string" }
+                              },
+                              required: ["type", "message"],
+                              type: "object"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["error"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        }
+                      ]
                     },
                     ok: { type: "boolean" }
                   },
@@ -9335,7 +10895,91 @@ var openapi_default = {
                 schema: {
                   properties: {
                     action_attempt: {
-                      $ref: "#/components/schemas/action_attempt"
+                      discriminator: { propertyName: "status" },
+                      oneOf: [
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: { nullable: true },
+                            status: { enum: ["success"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["pending"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              properties: {
+                                message: { type: "string" },
+                                type: { type: "string" }
+                              },
+                              required: ["type", "message"],
+                              type: "object"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["error"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        }
+                      ]
                     },
                     ok: { type: "boolean" }
                   },
@@ -9387,7 +11031,91 @@ var openapi_default = {
                 schema: {
                   properties: {
                     action_attempt: {
-                      $ref: "#/components/schemas/action_attempt"
+                      discriminator: { propertyName: "status" },
+                      oneOf: [
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: { nullable: true },
+                            status: { enum: ["success"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["pending"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              properties: {
+                                message: { type: "string" },
+                                type: { type: "string" }
+                              },
+                              required: ["type", "message"],
+                              type: "object"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["error"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        }
+                      ]
                     },
                     ok: { type: "boolean" }
                   },
@@ -9440,7 +11168,91 @@ var openapi_default = {
                 schema: {
                   properties: {
                     action_attempt: {
-                      $ref: "#/components/schemas/action_attempt"
+                      discriminator: { propertyName: "status" },
+                      oneOf: [
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: { nullable: true },
+                            status: { enum: ["success"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["pending"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        },
+                        {
+                          properties: {
+                            action_attempt_id: {
+                              format: "uuid",
+                              type: "string"
+                            },
+                            action_type: { type: "string" },
+                            error: {
+                              properties: {
+                                message: { type: "string" },
+                                type: { type: "string" }
+                              },
+                              required: ["type", "message"],
+                              type: "object"
+                            },
+                            result: {
+                              format: "null",
+                              nullable: true,
+                              type: "string"
+                            },
+                            status: { enum: ["error"], type: "string" }
+                          },
+                          required: [
+                            "status",
+                            "action_type",
+                            "action_attempt_id",
+                            "result",
+                            "error"
+                          ],
+                          type: "object"
+                        }
+                      ]
                     },
                     ok: { type: "boolean" }
                   },