workos 10.4.0 → 10.6.0

data/test/workos/test_shared_model_round_trip.rb

@@ -5,231 +5,1811 @@
 require "test_helper"
 
 class SharedModelRoundTripTest < Minitest::Test
+  def test_update_audit_logs_retention_with_retention_period_round_trip
+    fixture = {
+      "retention_period" => "stub"
+    }
+    model = WorkOS::UpdateAuditLogsRetentionWithRetentionPeriod.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_update_audit_logs_retention_with_retention_period_in_days_round_trip
+    fixture = {
+      "retention_period_in_days" => 1
+    }
+    model = WorkOS::UpdateAuditLogsRetentionWithRetentionPeriodInDays.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["retention_period_in_days"], json[:retention_period_in_days]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_update_user_organization_membership_with_role_slug_round_trip
+    fixture = {
+      "role_slug" => "stub"
+    }
+    model = WorkOS::UpdateUserOrganizationMembershipWithRoleSlug.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["role_slug"], json[:role_slug]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_update_user_organization_membership_with_role_slugs_round_trip
+    fixture = {
+      "role_slugs" => []
+    }
+    model = WorkOS::UpdateUserOrganizationMembershipWithRoleSlugs.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_error_body_with_code_round_trip
+    fixture = {
+      "code" => "stub",
+      "message" => "stub"
+    }
+    model = WorkOS::ErrorBodyWithCode.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["code"], json[:code]
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_error_body_with_error_round_trip
+    fixture = {
+      "error" => "stub",
+      "message" => "stub"
+    }
+    model = WorkOS::ErrorBodyWithError.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error"], json[:error]
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_error_body_round_trip
+    fixture = {
+      "message" => "stub"
+    }
+    model = WorkOS::ErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_error_body_with_code_field_errors_round_trip
+    fixture = {
+      "message" => "stub",
+      "errors" => []
+    }
+    model = WorkOS::ErrorBodyWithCodeFieldErrors.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_error_body_with_code_field_error_round_trip
+    fixture = {
+      "code" => "stub",
+      "field" => "stub"
+    }
+    model = WorkOS::ErrorBodyWithCodeFieldError.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["code"], json[:code]
+    assert_equal fixture["field"], json[:field]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_error_body_with_code_instance_path_errors_round_trip
+    fixture = {
+      "errors" => [],
+      "message" => "stub",
+      "code" => "stub"
+    }
+    model = WorkOS::ErrorBodyWithCodeInstancePathErrors.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    assert_equal fixture["code"], json[:code]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_error_body_with_code_instance_path_error_round_trip
+    fixture = {
+      "instancePath" => "stub"
+    }
+    model = WorkOS::ErrorBodyWithCodeInstancePathError.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["instancePath"], json[:instancePath]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_error_body_with_error_message_list_round_trip
+    fixture = {
+      "message" => [],
+      "error" => "stub"
+    }
+    model = WorkOS::ErrorBodyWithErrorMessageList.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error"], json[:error]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_too_many_failed_verification_attempts_error_body_with_retry_after_round_trip
+    fixture = {
+      "code" => "too_many_failed_verification_attempts",
+      "message" => "stub",
+      "retry_after" => 1
+    }
+    model = WorkOS::TooManyFailedVerificationAttemptsErrorBodyWithRetryAfter.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    assert_equal fixture["retry_after"], json[:retry_after]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_rate_limit_exceeded_error_body_with_retry_after_round_trip
+    fixture = {
+      "code" => "rate_limit_exceeded",
+      "message" => "stub",
+      "retry_after" => 1.0
+    }
+    model = WorkOS::RateLimitExceededErrorBodyWithRetryAfter.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    assert_equal fixture["retry_after"], json[:retry_after]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_error_body_with_constraints_property_errors_round_trip
+    fixture = {
+      "message" => "stub",
+      "errors" => []
+    }
+    model = WorkOS::ErrorBodyWithConstraintsPropertyErrors.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_error_body_with_constraints_property_error_round_trip
+    fixture = {
+      "property" => "stub",
+      "constraints" => {}
+    }
+    model = WorkOS::ErrorBodyWithConstraintsPropertyError.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_error_body_with_code_status_code_round_trip
+    fixture = {
+      "message" => "stub",
+      "code" => "stub",
+      "statusCode" => 1.0
+    }
+    model = WorkOS::ErrorBodyWithCodeStatusCode.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_error_body_with_message_or_message_list_round_trip
+    fixture = {
+      "message" => "stub"
+    }
+    model = WorkOS::ErrorBodyWithMessageOrMessageList.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_authorization_url_request_error_body_round_trip
+    fixture = {
+      "code" => "stub",
+      "message" => "stub"
+    }
+    model = WorkOS::AuthorizationUrlRequestErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_authorization_url_not_found_error_body_round_trip
+    fixture = {
+      "code" => "stub",
+      "message" => "stub"
+    }
+    model = WorkOS::AuthorizationUrlNotFoundErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_auth_method_mismatch_error_body_round_trip
+    fixture = {
+      "code" => "auth_method_mismatch",
+      "message" => "stub"
+    }
+    model = WorkOS::AuthMethodMismatchErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_account_selection_required_error_body_round_trip
+    fixture = {
+      "code" => "account_selection_required",
+      "message" => "stub"
+    }
+    model = WorkOS::AccountSelectionRequiredErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_error_body_with_code_errors_round_trip
+    fixture = {
+      "code" => "stub",
+      "message" => "stub",
+      "errors" => []
+    }
+    model = WorkOS::ErrorBodyWithCodeErrors.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_oauth_error_body_round_trip
+    fixture = {
+      "error" => "stub",
+      "error_description" => "stub"
+    }
+    model = WorkOS::OAuthErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error"], json[:error]
+    assert_equal fixture["error_description"], json[:error_description]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_sub_resource_scoped_role_not_allowed_error_body_with_role_slug_round_trip
+    fixture = {
+      "message" => "stub",
+      "code" => "sub_resource_scoped_role_not_allowed",
+      "role_slug" => "stub"
+    }
+    model = WorkOS::SubResourceScopedRoleNotAllowedErrorBodyWithRoleSlug.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    assert_equal fixture["role_slug"], json[:role_slug]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_unauthorized_error_body_round_trip
+    fixture = {
+      "error" => "Unauthorized"
+    }
+    model = WorkOS::UnauthorizedErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_external_auth_session_already_completed_error_body_round_trip
+    fixture = {
+      "code" => "external_auth_session_already_completed",
+      "message" => "stub"
+    }
+    model = WorkOS::ExternalAuthSessionAlreadyCompletedErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_invalid_email_error_body_round_trip
+    fixture = {
+      "code" => "invalid_email",
+      "message" => "stub"
+    }
+    model = WorkOS::InvalidEmailErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_already_claimed_error_body_round_trip
+    fixture = {
+      "code" => "already_claimed",
+      "message" => "stub"
+    }
+    model = WorkOS::AlreadyClaimedErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_sms_challenge_rate_limited_error_body_round_trip
+    fixture = {
+      "code" => "sms_challenge_rate_limited",
+      "message" => "stub"
+    }
+    model = WorkOS::SmsChallengeRateLimitedErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_sms_challenge_quota_reached_error_body_round_trip
+    fixture = {
+      "code" => "sms_challenge_quota_reached",
+      "message" => "stub"
+    }
+    model = WorkOS::SmsChallengeQuotaReachedErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_idp_metadata_fetch_failed_error_body_round_trip
+    fixture = {
+      "code" => "idp_metadata_fetch_failed",
+      "message" => "stub"
+    }
+    model = WorkOS::IdpMetadataFetchFailedErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_invalid_idp_sso_url_error_body_round_trip
+    fixture = {
+      "code" => "invalid_idp_sso_url",
+      "message" => "stub"
+    }
+    model = WorkOS::InvalidIdpSSOUrlErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_connected_account_limit_reached_error_body_round_trip
+    fixture = {
+      "code" => "connected_account_limit_reached",
+      "message" => "stub"
+    }
+    model = WorkOS::ConnectedAccountLimitReachedErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_entity_not_found_error_body_round_trip
+    fixture = {
+      "code" => "entity_not_found",
+      "message" => "stub"
+    }
+    model = WorkOS::EntityNotFoundErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_invalid_request_parameters_error_body_with_errors_round_trip
+    fixture = {
+      "code" => "invalid_request_parameters",
+      "message" => "stub",
+      "errors" => []
+    }
+    model = WorkOS::InvalidRequestParametersErrorBodyWithErrors.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_invalid_refresh_token_error_body_round_trip
+    fixture = {
+      "code" => "invalid_refresh_token",
+      "message" => "stub"
+    }
+    model = WorkOS::InvalidRefreshTokenErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_sign_up_not_allowed_oauth_error_body_round_trip
+    fixture = {
+      "error" => "sign_up_not_allowed",
+      "error_description" => "stub"
+    }
+    model = WorkOS::SignUpNotAllowedOAuthErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error_description"], json[:error_description]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_invalid_request_parameters_error_body_round_trip
+    fixture = {
+      "code" => "invalid_request_parameters",
+      "message" => "stub"
+    }
+    model = WorkOS::InvalidRequestParametersErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_invalid_role_error_body_round_trip
+    fixture = {
+      "code" => "invalid_role",
+      "message" => "stub"
+    }
+    model = WorkOS::InvalidRoleErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_multiple_roles_not_enabled_error_body_round_trip
+    fixture = {
+      "code" => "multiple_roles_not_enabled",
+      "message" => "stub"
+    }
+    model = WorkOS::MultipleRolesNotEnabledErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_invalid_password_hash_error_body_round_trip
+    fixture = {
+      "code" => "invalid_password_hash",
+      "message" => "stub"
+    }
+    model = WorkOS::InvalidPasswordHashErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_invalid_metadata_error_body_round_trip
+    fixture = {
+      "code" => "invalid_metadata",
+      "message" => "stub"
+    }
+    model = WorkOS::InvalidMetadataErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_external_id_already_used_error_body_round_trip
+    fixture = {
+      "code" => "external_id_already_used",
+      "message" => "stub"
+    }
+    model = WorkOS::ExternalIdAlreadyUsedErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_invalid_locale_error_body_round_trip
+    fixture = {
+      "code" => "invalid_locale",
+      "message" => "stub"
+    }
+    model = WorkOS::InvalidLocaleErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_invalid_organization_id_error_body_round_trip
+    fixture = {
+      "code" => "invalid_organization_id",
+      "message" => "stub"
+    }
+    model = WorkOS::InvalidOrganizationIdErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_code_challenge_not_found_error_body_round_trip
+    fixture = {
+      "code" => "code_challenge_not_found",
+      "message" => "stub"
+    }
+    model = WorkOS::CodeChallengeNotFoundErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_invalid_credentials_error_body_round_trip
+    fixture = {
+      "code" => "invalid_credentials",
+      "message" => "stub"
+    }
+    model = WorkOS::InvalidCredentialsErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_invalid_one_time_code_error_body_round_trip
+    fixture = {
+      "code" => "invalid_one_time_code",
+      "message" => "stub"
+    }
+    model = WorkOS::InvalidOneTimeCodeErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_one_time_code_previously_used_error_body_round_trip
+    fixture = {
+      "code" => "one_time_code_previously_used",
+      "message" => "stub"
+    }
+    model = WorkOS::OneTimeCodePreviouslyUsedErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_one_time_code_expired_error_body_round_trip
+    fixture = {
+      "code" => "one_time_code_expired",
+      "message" => "stub"
+    }
+    model = WorkOS::OneTimeCodeExpiredErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_one_time_code_too_many_attempts_error_body_round_trip
+    fixture = {
+      "code" => "one_time_code_too_many_attempts",
+      "message" => "stub"
+    }
+    model = WorkOS::OneTimeCodeTooManyAttemptsErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_invalid_pending_authentication_token_error_body_round_trip
+    fixture = {
+      "code" => "invalid_pending_authentication_token",
+      "message" => "stub"
+    }
+    model = WorkOS::InvalidPendingAuthenticationTokenErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_phone_number_required_error_body_round_trip
+    fixture = {
+      "code" => "phone_number_required",
+      "message" => "stub"
+    }
+    model = WorkOS::PhoneNumberRequiredErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_verification_id_required_error_body_round_trip
+    fixture = {
+      "code" => "verification_id_required",
+      "message" => "stub"
+    }
+    model = WorkOS::VerificationIdRequiredErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_invalid_client_oauth_error_body_round_trip
+    fixture = {
+      "error" => "invalid_client",
+      "error_description" => "stub"
+    }
+    model = WorkOS::InvalidClientOAuthErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error_description"], json[:error_description]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_unauthorized_client_oauth_error_body_round_trip
+    fixture = {
+      "error" => "unauthorized_client",
+      "error_description" => "stub"
+    }
+    model = WorkOS::UnauthorizedClientOAuthErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error_description"], json[:error_description]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_invalid_profile_oauth_error_body_round_trip
+    fixture = {
+      "error" => "invalid_profile",
+      "error_description" => "stub"
+    }
+    model = WorkOS::InvalidProfileOAuthErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error_description"], json[:error_description]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_invalid_connection_oauth_error_body_round_trip
+    fixture = {
+      "error" => "invalid_connection",
+      "error_description" => "stub"
+    }
+    model = WorkOS::InvalidConnectionOAuthErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error_description"], json[:error_description]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_invalid_link_authorization_code_oauth_error_body_round_trip
+    fixture = {
+      "error" => "invalid_link_authorization_code",
+      "error_description" => "stub"
+    }
+    model = WorkOS::InvalidLinkAuthorizationCodeOAuthErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error_description"], json[:error_description]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_extra_attributes_required_oauth_error_body_round_trip
+    fixture = {
+      "error" => "extra_attributes_required",
+      "error_description" => "stub"
+    }
+    model = WorkOS::ExtraAttributesRequiredOAuthErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error_description"], json[:error_description]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_pkce_not_supported_oauth_error_body_round_trip
+    fixture = {
+      "error" => "pkce_not_supported",
+      "error_description" => "stub"
+    }
+    model = WorkOS::PkceNotSupportedOAuthErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error_description"], json[:error_description]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_expired_token_oauth_error_body_round_trip
+    fixture = {
+      "error" => "expired_token",
+      "error_description" => "stub"
+    }
+    model = WorkOS::ExpiredTokenOAuthErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error_description"], json[:error_description]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_authorization_pending_oauth_error_body_round_trip
+    fixture = {
+      "error" => "authorization_pending",
+      "error_description" => "stub"
+    }
+    model = WorkOS::AuthorizationPendingOAuthErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error_description"], json[:error_description]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_access_denied_oauth_error_body_round_trip
+    fixture = {
+      "error" => "access_denied",
+      "error_description" => "stub"
+    }
+    model = WorkOS::AccessDeniedOAuthErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error_description"], json[:error_description]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_slow_down_oauth_error_body_round_trip
+    fixture = {
+      "error" => "slow_down",
+      "error_description" => "stub"
+    }
+    model = WorkOS::SlowDownOAuthErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error_description"], json[:error_description]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_must_use_sso_for_selected_organization_message_error_body_round_trip
+    fixture = {
+      "message" => "Must use SSO for selected organization"
+    }
+    model = WorkOS::MustUseSSOForSelectedOrganizationMessageErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_invalid_grant_oauth_error_body_round_trip
+    fixture = {
+      "error" => "invalid_grant",
+      "error_description" => "stub"
+    }
+    model = WorkOS::InvalidGrantOAuthErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error_description"], json[:error_description]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_invalid_request_oauth_error_body_round_trip
+    fixture = {
+      "error" => "invalid_request",
+      "error_description" => "stub"
+    }
+    model = WorkOS::InvalidRequestOAuthErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error_description"], json[:error_description]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_mfa_enrollment_oauth_error_body_round_trip
+    fixture = {
+      "error" => "mfa_enrollment",
+      "error_description" => "stub"
+    }
+    model = WorkOS::MFAEnrollmentOAuthErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error_description"], json[:error_description]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_token_too_big_oauth_error_body_round_trip
+    fixture = {
+      "error" => "token_too_big",
+      "error_description" => "stub"
+    }
+    model = WorkOS::TokenTooBigOAuthErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error_description"], json[:error_description]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_mfa_enrollment_error_body_round_trip
+    fixture = {
+      "code" => "mfa_enrollment",
+      "message" => "stub"
+    }
+    model = WorkOS::MFAEnrollmentErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_mfa_challenge_error_body_round_trip
+    fixture = {
+      "code" => "mfa_challenge",
+      "message" => "stub"
+    }
+    model = WorkOS::MFAChallengeErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_passkey_progressive_enrollment_error_body_round_trip
+    fixture = {
+      "code" => "passkey_progressive_enrollment",
+      "message" => "stub"
+    }
+    model = WorkOS::PasskeyProgressiveEnrollmentErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_radar_challenge_error_body_round_trip
+    fixture = {
+      "code" => "radar_challenge",
+      "message" => "stub"
+    }
+    model = WorkOS::RadarChallengeErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_radar_sign_up_challenge_error_body_round_trip
+    fixture = {
+      "code" => "radar_sign_up_challenge",
+      "message" => "stub"
+    }
+    model = WorkOS::RadarSignUpChallengeErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_radar_sms_sign_in_challenge_error_body_round_trip
+    fixture = {
+      "code" => "radar_sms_sign_in_challenge",
+      "message" => "stub"
+    }
+    model = WorkOS::RadarSmsSignInChallengeErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_application_consent_required_error_body_round_trip
+    fixture = {
+      "code" => "application_consent_required",
+      "message" => "stub"
+    }
+    model = WorkOS::ApplicationConsentRequiredErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_policy_denied_error_body_round_trip
+    fixture = {
+      "code" => "policy_denied",
+      "message" => "stub"
+    }
+    model = WorkOS::PolicyDeniedErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_daily_quota_exceeded_error_body_round_trip
+    fixture = {
+      "code" => "daily_quota_exceeded",
+      "message" => "stub"
+    }
+    model = WorkOS::DailyQuotaExceededErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_too_many_requests_oauth_error_body_round_trip
+    fixture = {
+      "error" => "too_many_requests",
+      "error_description" => "stub"
+    }
+    model = WorkOS::TooManyRequestsOAuthErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error_description"], json[:error_description]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_invalid_url_error_body_round_trip
+    fixture = {
+      "code" => "invalid_url",
+      "message" => "stub"
+    }
+    model = WorkOS::InvalidUrlErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
   def test_error_response_round_trip
     fixture = {
-      "error" => "stub"
+      "error" => "stub"
+    }
+    model = WorkOS::ErrorResponse.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error"], json[:error]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_object_summary_round_trip
+    fixture = {
+      "id" => "stub",
+      "name" => "stub",
+      "updated_at" => nil
+    }
+    model = WorkOS::ObjectSummary.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["name"], json[:name]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_connect_application_oauth_round_trip
+    fixture = {
+      "object" => "connect_application",
+      "id" => "stub",
+      "client_id" => "stub",
+      "description" => nil,
+      "name" => "stub",
+      "scopes" => [],
+      "created_at" => "stub",
+      "updated_at" => "stub",
+      "application_type" => "oauth",
+      "redirect_uris" => [],
+      "cors_origins" => [],
+      "uses_pkce" => true,
+      "is_first_party" => true,
+      "was_dynamically_registered" => true,
+      "organization_id" => "stub"
+    }
+    model = WorkOS::ConnectApplicationOAuth.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["client_id"], json[:client_id]
+    assert_nil json[:description]
+    assert_equal fixture["name"], json[:name]
+    assert_equal fixture["created_at"], json[:created_at]
+    assert_equal fixture["updated_at"], json[:updated_at]
+    assert_equal fixture["uses_pkce"], json[:uses_pkce]
+    assert_equal fixture["is_first_party"], json[:is_first_party]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_connect_application_oauth_redirect_uris_round_trip
+    fixture = {
+      "uri" => "stub",
+      "default" => true
+    }
+    model = WorkOS::ConnectApplicationOAuthRedirectUris.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["uri"], json[:uri]
+    assert_equal fixture["default"], json[:default]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_connect_application_m2m_round_trip
+    fixture = {
+      "object" => "connect_application",
+      "id" => "stub",
+      "client_id" => "stub",
+      "description" => nil,
+      "name" => "stub",
+      "scopes" => [],
+      "created_at" => "stub",
+      "updated_at" => "stub",
+      "application_type" => "m2m",
+      "organization_id" => "stub"
+    }
+    model = WorkOS::ConnectApplicationM2M.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["client_id"], json[:client_id]
+    assert_nil json[:description]
+    assert_equal fixture["name"], json[:name]
+    assert_equal fixture["created_at"], json[:created_at]
+    assert_equal fixture["updated_at"], json[:updated_at]
+    assert_equal fixture["organization_id"], json[:organization_id]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_event_context_actor_round_trip
+    fixture = {
+      "id" => "stub",
+      "source" => "stub",
+      "name" => nil
+    }
+    model = WorkOS::EventContextActor.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_nil json[:name]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_event_context_round_trip
+    fixture = {
+      "google_analytics_client_id" => "stub",
+      "google_analytics_sessions" => [],
+      "ajs_anonymous_id" => "stub",
+      "client_id" => "stub",
+      "actor" => {},
+      "previous_attributes" => {}
+    }
+    model = WorkOS::EventContext.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_pipe_connected_account_round_trip
+    fixture = {
+      "object" => "connected_account",
+      "id" => "stub",
+      "connection_role" => "stub",
+      "account_identifier" => nil,
+      "account_display_name" => nil,
+      "data_integration_id" => "stub",
+      "provider_slug" => "stub",
+      "user_id" => nil,
+      "organization_id" => nil,
+      "scopes" => [],
+      "auth_method" => "stub",
+      "api_key_last_4" => nil,
+      "state" => "stub",
+      "established_by_user_id" => nil,
+      "state_reason" => nil,
+      "created_at" => "stub",
+      "updated_at" => "stub"
+    }
+    model = WorkOS::PipeConnectedAccount.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["data_integration_id"], json[:data_integration_id]
+    assert_equal fixture["provider_slug"], json[:provider_slug]
+    assert_nil json[:user_id]
+    assert_nil json[:organization_id]
+    assert_equal fixture["created_at"], json[:created_at]
+    assert_equal fixture["updated_at"], json[:updated_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_waitlist_user_round_trip
+    fixture = {
+      "id" => "stub",
+      "email" => "stub",
+      "state" => "stub",
+      "approved_at" => nil,
+      "additional_fields" => {},
+      "waitlist_id" => nil,
+      "created_at" => "stub",
+      "updated_at" => "stub",
+      "object" => "waitlist_user"
+    }
+    model = WorkOS::WaitlistUser.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["email"], json[:email]
+    assert_nil json[:approved_at]
+    assert_equal fixture["created_at"], json[:created_at]
+    assert_equal fixture["updated_at"], json[:updated_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_event_schema_round_trip
+    fixture = {
+      "object" => "event",
+      "id" => "stub",
+      "event" => "stub",
+      "data" => {},
+      "created_at" => "stub",
+      "context" => {}
+    }
+    model = WorkOS::EventSchema.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["event"], json[:event]
+    assert_equal fixture["created_at"], json[:created_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_blueprint_created_round_trip
+    fixture = {
+      "object" => "event",
+      "id" => "stub",
+      "event" => "agent.blueprint.created",
+      "data" => {},
+      "created_at" => "stub",
+      "context" => {}
+    }
+    model = WorkOS::AgentBlueprintCreated.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["created_at"], json[:created_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_blueprint_created_data_round_trip
+    fixture = {
+      "object" => "agent_blueprint",
+      "id" => "stub",
+      "name" => "stub",
+      "description" => nil,
+      "permissions" => [],
+      "invocable_by" => {},
+      "invocable_as" => {},
+      "session_settings" => {},
+      "created_at" => "stub",
+      "updated_at" => "stub"
+    }
+    model = WorkOS::AgentBlueprintCreatedData.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["name"], json[:name]
+    assert_nil json[:description]
+    assert_equal fixture["created_at"], json[:created_at]
+    assert_equal fixture["updated_at"], json[:updated_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_blueprint_created_data_invocable_by_round_trip
+    fixture = {
+      "role_slugs" => [],
+      "organization_ids" => []
+    }
+    model = WorkOS::AgentBlueprintCreatedDataInvocableBy.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_blueprint_created_data_invocable_as_round_trip
+    fixture = {
+      "instance_types" => []
+    }
+    model = WorkOS::AgentBlueprintCreatedDataInvocableAs.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_blueprint_created_data_session_setting_round_trip
+    fixture = {
+      "max_age_seconds" => 1.0,
+      "access_token_ttl_seconds" => 1.0,
+      "refresh_token_ttl_seconds" => 1.0
+    }
+    model = WorkOS::AgentBlueprintCreatedDataSessionSetting.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["max_age_seconds"], json[:max_age_seconds]
+    assert_equal fixture["access_token_ttl_seconds"], json[:access_token_ttl_seconds]
+    assert_equal fixture["refresh_token_ttl_seconds"], json[:refresh_token_ttl_seconds]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_blueprint_deleted_round_trip
+    fixture = {
+      "object" => "event",
+      "id" => "stub",
+      "event" => "agent.blueprint.deleted",
+      "data" => {},
+      "created_at" => "stub",
+      "context" => {}
+    }
+    model = WorkOS::AgentBlueprintDeleted.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["created_at"], json[:created_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_blueprint_deleted_data_round_trip
+    fixture = {
+      "object" => "agent_blueprint",
+      "id" => "stub",
+      "name" => "stub",
+      "created_at" => "stub",
+      "updated_at" => "stub"
+    }
+    model = WorkOS::AgentBlueprintDeletedData.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["name"], json[:name]
+    assert_equal fixture["created_at"], json[:created_at]
+    assert_equal fixture["updated_at"], json[:updated_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_blueprint_updated_round_trip
+    fixture = {
+      "object" => "event",
+      "id" => "stub",
+      "event" => "agent.blueprint.updated",
+      "data" => {},
+      "created_at" => "stub",
+      "context" => {}
+    }
+    model = WorkOS::AgentBlueprintUpdated.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["created_at"], json[:created_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_blueprint_updated_data_round_trip
+    fixture = {
+      "object" => "agent_blueprint",
+      "id" => "stub",
+      "name" => "stub",
+      "description" => nil,
+      "permissions" => [],
+      "invocable_by" => {},
+      "invocable_as" => {},
+      "session_settings" => {},
+      "created_at" => "stub",
+      "updated_at" => "stub"
+    }
+    model = WorkOS::AgentBlueprintUpdatedData.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["name"], json[:name]
+    assert_nil json[:description]
+    assert_equal fixture["created_at"], json[:created_at]
+    assert_equal fixture["updated_at"], json[:updated_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_blueprint_updated_data_invocable_by_round_trip
+    fixture = {
+      "role_slugs" => [],
+      "organization_ids" => []
+    }
+    model = WorkOS::AgentBlueprintUpdatedDataInvocableBy.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_blueprint_updated_data_invocable_as_round_trip
+    fixture = {
+      "instance_types" => []
+    }
+    model = WorkOS::AgentBlueprintUpdatedDataInvocableAs.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_blueprint_updated_data_session_setting_round_trip
+    fixture = {
+      "max_age_seconds" => 1.0,
+      "access_token_ttl_seconds" => 1.0,
+      "refresh_token_ttl_seconds" => 1.0
+    }
+    model = WorkOS::AgentBlueprintUpdatedDataSessionSetting.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["max_age_seconds"], json[:max_age_seconds]
+    assert_equal fixture["access_token_ttl_seconds"], json[:access_token_ttl_seconds]
+    assert_equal fixture["refresh_token_ttl_seconds"], json[:refresh_token_ttl_seconds]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_instance_created_round_trip
+    fixture = {
+      "object" => "event",
+      "id" => "stub",
+      "event" => "agent.instance.created",
+      "data" => {},
+      "created_at" => "stub",
+      "context" => {}
+    }
+    model = WorkOS::AgentInstanceCreated.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["created_at"], json[:created_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_instance_created_data_round_trip
+    fixture = {
+      "object" => "agent_instance",
+      "id" => "stub",
+      "agent_blueprint_id" => "stub",
+      "organization_id" => "stub",
+      "organization_membership_id" => nil,
+      "type" => "stub",
+      "created_at" => "stub",
+      "updated_at" => "stub"
+    }
+    model = WorkOS::AgentInstanceCreatedData.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["agent_blueprint_id"], json[:agent_blueprint_id]
+    assert_equal fixture["organization_id"], json[:organization_id]
+    assert_nil json[:organization_membership_id]
+    assert_equal fixture["created_at"], json[:created_at]
+    assert_equal fixture["updated_at"], json[:updated_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_instance_deleted_round_trip
+    fixture = {
+      "object" => "event",
+      "id" => "stub",
+      "event" => "agent.instance.deleted",
+      "data" => {},
+      "created_at" => "stub",
+      "context" => {}
+    }
+    model = WorkOS::AgentInstanceDeleted.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["created_at"], json[:created_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_instance_deleted_data_round_trip
+    fixture = {
+      "object" => "agent_instance",
+      "id" => "stub",
+      "agent_blueprint_id" => "stub",
+      "organization_id" => "stub",
+      "organization_membership_id" => nil,
+      "type" => "stub",
+      "created_at" => "stub",
+      "updated_at" => "stub"
+    }
+    model = WorkOS::AgentInstanceDeletedData.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["agent_blueprint_id"], json[:agent_blueprint_id]
+    assert_equal fixture["organization_id"], json[:organization_id]
+    assert_nil json[:organization_membership_id]
+    assert_equal fixture["created_at"], json[:created_at]
+    assert_equal fixture["updated_at"], json[:updated_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_instance_session_created_round_trip
+    fixture = {
+      "object" => "event",
+      "id" => "stub",
+      "event" => "agent.instance.session.created",
+      "data" => {},
+      "created_at" => "stub",
+      "context" => {}
+    }
+    model = WorkOS::AgentInstanceSessionCreated.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["created_at"], json[:created_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_instance_session_created_data_round_trip
+    fixture = {
+      "object" => "agent_instance_session",
+      "id" => "stub",
+      "agent_instance_id" => "stub",
+      "organization_id" => "stub",
+      "expires_at" => "stub",
+      "revoked_at" => nil,
+      "created_at" => "stub",
+      "updated_at" => "stub",
+      "permission_slugs" => []
+    }
+    model = WorkOS::AgentInstanceSessionCreatedData.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["agent_instance_id"], json[:agent_instance_id]
+    assert_equal fixture["organization_id"], json[:organization_id]
+    assert_equal fixture["expires_at"], json[:expires_at]
+    assert_nil json[:revoked_at]
+    assert_equal fixture["created_at"], json[:created_at]
+    assert_equal fixture["updated_at"], json[:updated_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_instance_session_revoked_round_trip
+    fixture = {
+      "object" => "event",
+      "id" => "stub",
+      "event" => "agent.instance.session.revoked",
+      "data" => {},
+      "created_at" => "stub",
+      "context" => {}
+    }
+    model = WorkOS::AgentInstanceSessionRevoked.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["created_at"], json[:created_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_instance_session_revoked_data_round_trip
+    fixture = {
+      "object" => "agent_instance_session",
+      "id" => "stub",
+      "agent_instance_id" => "stub",
+      "organization_id" => "stub",
+      "expires_at" => "stub",
+      "revoked_at" => nil,
+      "created_at" => "stub",
+      "updated_at" => "stub"
+    }
+    model = WorkOS::AgentInstanceSessionRevokedData.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["agent_instance_id"], json[:agent_instance_id]
+    assert_equal fixture["organization_id"], json[:organization_id]
+    assert_equal fixture["expires_at"], json[:expires_at]
+    assert_nil json[:revoked_at]
+    assert_equal fixture["created_at"], json[:created_at]
+    assert_equal fixture["updated_at"], json[:updated_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_registration_claim_attempt_created_round_trip
+    fixture = {
+      "object" => "event",
+      "id" => "stub",
+      "event" => "agent.registration.claim.attempt.created",
+      "data" => {},
+      "created_at" => "stub",
+      "context" => {}
     }
-    model = WorkOS::ErrorResponse.new(fixture.to_json)
+    model = WorkOS::AgentRegistrationClaimAttemptCreated.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
-    assert_equal fixture["error"], json[:error]
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["created_at"], json[:created_at]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_object_summary_round_trip
+  def test_agent_registration_claim_attempt_created_data_round_trip
     fixture = {
+      "object" => "agent_registration_claim_attempt",
       "id" => "stub",
-      "name" => "stub",
-      "updated_at" => nil
+      "agent_registration_id" => "stub",
+      "agent_registration_claim_id" => "stub",
+      "login_hint" => "stub",
+      "expires_at" => "stub",
+      "created_at" => "stub",
+      "updated_at" => "stub"
     }
-    model = WorkOS::ObjectSummary.new(fixture.to_json)
+    model = WorkOS::AgentRegistrationClaimAttemptCreatedData.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
-    assert_equal fixture["name"], json[:name]
+    assert_equal fixture["agent_registration_id"], json[:agent_registration_id]
+    assert_equal fixture["agent_registration_claim_id"], json[:agent_registration_claim_id]
+    assert_equal fixture["login_hint"], json[:login_hint]
+    assert_equal fixture["expires_at"], json[:expires_at]
+    assert_equal fixture["created_at"], json[:created_at]
+    assert_equal fixture["updated_at"], json[:updated_at]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_object_version_round_trip
+  def test_agent_registration_claim_completed_round_trip
     fixture = {
-      "created_at" => "stub",
-      "current_version" => true,
-      "etag" => "stub",
+      "object" => "event",
       "id" => "stub",
-      "size" => 1
+      "event" => "agent.registration.claim.completed",
+      "data" => {},
+      "created_at" => "stub",
+      "context" => {}
     }
-    model = WorkOS::ObjectVersion.new(fixture.to_json)
+    model = WorkOS::AgentRegistrationClaimCompleted.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
-    assert_equal fixture["created_at"], json[:created_at]
-    assert_equal fixture["current_version"], json[:current_version]
-    assert_equal fixture["etag"], json[:etag]
     assert_equal fixture["id"], json[:id]
-    assert_equal fixture["size"], json[:size]
+    assert_equal fixture["created_at"], json[:created_at]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_connect_application_oauth_round_trip
+  def test_agent_registration_claim_completed_data_round_trip
     fixture = {
-      "object" => "connect_application",
+      "object" => "agent_registration_claim",
       "id" => "stub",
-      "client_id" => "stub",
-      "description" => nil,
-      "name" => "stub",
-      "scopes" => [],
+      "agent_registration_id" => "stub",
+      "completed_by_attempt_id" => "stub",
+      "claimed_by" => {},
+      "completed_at" => "stub",
       "created_at" => "stub",
-      "updated_at" => "stub",
-      "application_type" => "oauth",
-      "redirect_uris" => [],
-      "uses_pkce" => true,
-      "is_first_party" => true,
-      "was_dynamically_registered" => true,
-      "organization_id" => "stub"
+      "updated_at" => "stub"
     }
-    model = WorkOS::ConnectApplicationOAuth.new(fixture.to_json)
+    model = WorkOS::AgentRegistrationClaimCompletedData.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
-    assert_equal fixture["client_id"], json[:client_id]
-    assert_nil json[:description]
-    assert_equal fixture["name"], json[:name]
+    assert_equal fixture["agent_registration_id"], json[:agent_registration_id]
+    assert_equal fixture["completed_by_attempt_id"], json[:completed_by_attempt_id]
+    assert_equal fixture["completed_at"], json[:completed_at]
     assert_equal fixture["created_at"], json[:created_at]
     assert_equal fixture["updated_at"], json[:updated_at]
-    assert_equal fixture["uses_pkce"], json[:uses_pkce]
-    assert_equal fixture["is_first_party"], json[:is_first_party]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_connect_application_oauth_redirect_uris_round_trip
+  def test_agent_registration_claim_completed_data_claimed_by_round_trip
     fixture = {
-      "uri" => "stub",
-      "default" => true
+      "user_id" => "stub",
+      "organization_id" => "stub"
     }
-    model = WorkOS::ConnectApplicationOAuthRedirectUris.new(fixture.to_json)
+    model = WorkOS::AgentRegistrationClaimCompletedDataClaimedBy.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
-    assert_equal fixture["uri"], json[:uri]
-    assert_equal fixture["default"], json[:default]
+    assert_equal fixture["user_id"], json[:user_id]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_connect_application_m2m_round_trip
+  def test_agent_registration_created_round_trip
     fixture = {
-      "object" => "connect_application",
+      "object" => "event",
       "id" => "stub",
-      "client_id" => "stub",
-      "description" => nil,
-      "name" => "stub",
-      "scopes" => [],
+      "event" => "agent.registration.created",
+      "data" => {},
       "created_at" => "stub",
-      "updated_at" => "stub",
-      "application_type" => "m2m",
-      "organization_id" => "stub"
+      "context" => {}
     }
-    model = WorkOS::ConnectApplicationM2M.new(fixture.to_json)
+    model = WorkOS::AgentRegistrationCreated.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
-    assert_equal fixture["client_id"], json[:client_id]
-    assert_nil json[:description]
-    assert_equal fixture["name"], json[:name]
     assert_equal fixture["created_at"], json[:created_at]
-    assert_equal fixture["updated_at"], json[:updated_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_registration_created_data_round_trip
+    fixture = {
+      "object" => "agent_registration",
+      "id" => "stub",
+      "agent_identity" => {},
+      "organization_id" => "stub",
+      "status" => "stub",
+      "kind" => "stub",
+      "method" => "stub",
+      "created_at" => "stub",
+      "updated_at" => "stub"
+    }
+    model = WorkOS::AgentRegistrationCreatedData.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
     assert_equal fixture["organization_id"], json[:organization_id]
+    assert_equal fixture["created_at"], json[:created_at]
+    assert_equal fixture["updated_at"], json[:updated_at]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_event_context_actor_round_trip
+  def test_agent_registration_created_data_agent_identity_round_trip
     fixture = {
+      "object" => "agent_identity",
       "id" => "stub",
-      "source" => "stub",
-      "name" => nil
+      "userland_user_id" => "stub"
     }
-    model = WorkOS::EventContextActor.new(fixture.to_json)
+    model = WorkOS::AgentRegistrationCreatedDataAgentIdentity.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
-    assert_nil json[:name]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_event_context_round_trip
+  def test_agent_registration_credential_issued_round_trip
     fixture = {
-      "google_analytics_client_id" => "stub",
-      "google_analytics_sessions" => [],
-      "ajs_anonymous_id" => "stub",
-      "client_id" => "stub",
-      "actor" => {},
-      "previous_attributes" => {}
+      "object" => "event",
+      "id" => "stub",
+      "event" => "agent.registration.credential.issued",
+      "data" => {},
+      "created_at" => "stub",
+      "context" => {}
     }
-    model = WorkOS::EventContext.new(fixture.to_json)
+    model = WorkOS::AgentRegistrationCredentialIssued.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["created_at"], json[:created_at]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_pipe_connected_account_round_trip
+  def test_agent_registration_credential_issued_data_round_trip
     fixture = {
-      "object" => "connected_account",
+      "object" => "agent_registration_credential",
       "id" => "stub",
-      "connection_role" => "stub",
-      "account_identifier" => nil,
-      "account_display_name" => nil,
-      "data_integration_id" => "stub",
-      "provider_slug" => "stub",
-      "user_id" => nil,
-      "organization_id" => nil,
-      "scopes" => [],
-      "auth_method" => "stub",
-      "api_key_last_4" => nil,
-      "state" => "stub",
+      "agent_registration_id" => "stub",
+      "detail" => {},
       "created_at" => "stub",
       "updated_at" => "stub"
     }
-    model = WorkOS::PipeConnectedAccount.new(fixture.to_json)
+    model = WorkOS::AgentRegistrationCredentialIssuedData.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
-    assert_equal fixture["data_integration_id"], json[:data_integration_id]
-    assert_equal fixture["provider_slug"], json[:provider_slug]
-    assert_nil json[:user_id]
-    assert_nil json[:organization_id]
+    assert_equal fixture["agent_registration_id"], json[:agent_registration_id]
     assert_equal fixture["created_at"], json[:created_at]
     assert_equal fixture["updated_at"], json[:updated_at]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_waitlist_user_round_trip
+  def test_agent_registration_credential_issued_data_detail_round_trip
+    fixture = {
+      "kind" => "api_key",
+      "api_key_id" => "stub"
+    }
+    model = WorkOS::AgentRegistrationCredentialIssuedDataDetail.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["api_key_id"], json[:api_key_id]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_access_token_agent_registration_credential_issued_data_detail_round_trip
+    fixture = {
+      "kind" => "access_token",
+      "jti" => "stub",
+      "expires_at" => "stub"
+    }
+    model = WorkOS::AccessTokenAgentRegistrationCredentialIssuedDataDetail.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["jti"], json[:jti]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_registration_deleted_round_trip
     fixture = {
+      "object" => "event",
       "id" => "stub",
-      "email" => "stub",
-      "state" => "stub",
-      "approved_at" => nil,
-      "additional_fields" => {},
-      "waitlist_id" => nil,
+      "event" => "agent.registration.deleted",
+      "data" => {},
       "created_at" => "stub",
-      "updated_at" => "stub",
-      "object" => "waitlist_user"
+      "context" => {}
     }
-    model = WorkOS::WaitlistUser.new(fixture.to_json)
+    model = WorkOS::AgentRegistrationDeleted.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
-    assert_equal fixture["email"], json[:email]
-    assert_nil json[:approved_at]
     assert_equal fixture["created_at"], json[:created_at]
-    assert_equal fixture["updated_at"], json[:updated_at]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_event_schema_round_trip
+  def test_agent_registration_deleted_data_round_trip
+    fixture = {
+      "agent_registration_id" => "stub"
+    }
+    model = WorkOS::AgentRegistrationDeletedData.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["agent_registration_id"], json[:agent_registration_id]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_registration_expired_round_trip
     fixture = {
       "object" => "event",
       "id" => "stub",
-      "event" => "stub",
+      "event" => "agent.registration.expired",
       "data" => {},
       "created_at" => "stub",
       "context" => {}
     }
-    model = WorkOS::EventSchema.new(fixture.to_json)
+    model = WorkOS::AgentRegistrationExpired.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["created_at"], json[:created_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_agent_registration_expired_data_round_trip
+    fixture = {
+      "agent_registration_id" => "stub"
+    }
+    model = WorkOS::AgentRegistrationExpiredData.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
-    assert_equal fixture["id"], json[:id]
-    assert_equal fixture["event"], json[:event]
-    assert_equal fixture["created_at"], json[:created_at]
+    assert_equal fixture["agent_registration_id"], json[:agent_registration_id]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_blueprint_created_round_trip
+  def test_agent_registration_organization_switched_round_trip
     fixture = {
       "object" => "event",
       "id" => "stub",
-      "event" => "agent.blueprint.created",
+      "event" => "agent.registration.organization.switched",
       "data" => {},
       "created_at" => "stub",
       "context" => {}
     }
-    model = WorkOS::AgentBlueprintCreated.new(fixture.to_json)
+    model = WorkOS::AgentRegistrationOrganizationSwitched.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
@@ -237,65 +1817,59 @@ class SharedModelRoundTripTest < Minitest::Test
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_blueprint_created_data_round_trip
+  def test_agent_registration_organization_switched_data_round_trip
     fixture = {
-      "object" => "agent_blueprint",
-      "id" => "stub",
-      "name" => "stub",
-      "description" => nil,
-      "permissions" => [],
-      "invocable_by" => {},
-      "session_settings" => {},
-      "created_at" => "stub",
-      "updated_at" => "stub"
+      "agent_registration_id" => "stub",
+      "from_organization_id" => "stub",
+      "to_organization_id" => "stub"
     }
-    model = WorkOS::AgentBlueprintCreatedData.new(fixture.to_json)
+    model = WorkOS::AgentRegistrationOrganizationSwitchedData.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
-    assert_equal fixture["id"], json[:id]
-    assert_equal fixture["name"], json[:name]
-    assert_nil json[:description]
-    assert_equal fixture["created_at"], json[:created_at]
-    assert_equal fixture["updated_at"], json[:updated_at]
+    assert_equal fixture["agent_registration_id"], json[:agent_registration_id]
+    assert_equal fixture["from_organization_id"], json[:from_organization_id]
+    assert_equal fixture["to_organization_id"], json[:to_organization_id]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_blueprint_created_data_invocable_by_round_trip
+  def test_agent_registration_refreshed_round_trip
     fixture = {
-      "role_slugs" => [],
-      "organization_ids" => []
+      "object" => "event",
+      "id" => "stub",
+      "event" => "agent.registration.refreshed",
+      "data" => {},
+      "created_at" => "stub",
+      "context" => {}
     }
-    model = WorkOS::AgentBlueprintCreatedDataInvocableBy.new(fixture.to_json)
+    model = WorkOS::AgentRegistrationRefreshed.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["created_at"], json[:created_at]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_blueprint_created_data_session_setting_round_trip
+  def test_agent_registration_refreshed_data_round_trip
     fixture = {
-      "max_age_seconds" => 1.0,
-      "access_token_ttl_seconds" => 1.0,
-      "refresh_token_ttl_seconds" => 1.0
+      "agent_registration_id" => "stub"
     }
-    model = WorkOS::AgentBlueprintCreatedDataSessionSetting.new(fixture.to_json)
+    model = WorkOS::AgentRegistrationRefreshedData.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
-    assert_equal fixture["max_age_seconds"], json[:max_age_seconds]
-    assert_equal fixture["access_token_ttl_seconds"], json[:access_token_ttl_seconds]
-    assert_equal fixture["refresh_token_ttl_seconds"], json[:refresh_token_ttl_seconds]
+    assert_equal fixture["agent_registration_id"], json[:agent_registration_id]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_blueprint_deleted_round_trip
+  def test_agent_registration_revoked_round_trip
     fixture = {
       "object" => "event",
       "id" => "stub",
-      "event" => "agent.blueprint.deleted",
+      "event" => "agent.registration.revoked",
       "data" => {},
       "created_at" => "stub",
       "context" => {}
     }
-    model = WorkOS::AgentBlueprintDeleted.new(fixture.to_json)
+    model = WorkOS::AgentRegistrationRevoked.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
@@ -303,34 +1877,27 @@ class SharedModelRoundTripTest < Minitest::Test
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_blueprint_deleted_data_round_trip
+  def test_agent_registration_revoked_data_round_trip
     fixture = {
-      "object" => "agent_blueprint",
-      "id" => "stub",
-      "name" => "stub",
-      "created_at" => "stub",
-      "updated_at" => "stub"
+      "agent_registration_id" => "stub"
     }
-    model = WorkOS::AgentBlueprintDeletedData.new(fixture.to_json)
+    model = WorkOS::AgentRegistrationRevokedData.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
-    assert_equal fixture["id"], json[:id]
-    assert_equal fixture["name"], json[:name]
-    assert_equal fixture["created_at"], json[:created_at]
-    assert_equal fixture["updated_at"], json[:updated_at]
+    assert_equal fixture["agent_registration_id"], json[:agent_registration_id]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_blueprint_updated_round_trip
+  def test_feature_flags_flag_created_round_trip
     fixture = {
       "object" => "event",
       "id" => "stub",
-      "event" => "agent.blueprint.updated",
+      "event" => "feature_flags.flag.created",
       "data" => {},
       "created_at" => "stub",
       "context" => {}
     }
-    model = WorkOS::AgentBlueprintUpdated.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagCreated.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
@@ -338,187 +1905,175 @@ class SharedModelRoundTripTest < Minitest::Test
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_blueprint_updated_data_round_trip
+  def test_feature_flags_flag_created_data_round_trip
     fixture = {
-      "object" => "agent_blueprint",
+      "object" => "feature_flag",
       "id" => "stub",
+      "environment_id" => "stub",
+      "slug" => "stub",
       "name" => "stub",
       "description" => nil,
-      "permissions" => [],
-      "invocable_by" => {},
-      "session_settings" => {},
+      "owner" => nil,
+      "tags" => [],
+      "enabled" => true,
+      "default_value" => true,
       "created_at" => "stub",
       "updated_at" => "stub"
     }
-    model = WorkOS::AgentBlueprintUpdatedData.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagCreatedData.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
+    assert_equal fixture["environment_id"], json[:environment_id]
+    assert_equal fixture["slug"], json[:slug]
     assert_equal fixture["name"], json[:name]
     assert_nil json[:description]
+    assert_equal fixture["enabled"], json[:enabled]
+    assert_equal fixture["default_value"], json[:default_value]
     assert_equal fixture["created_at"], json[:created_at]
     assert_equal fixture["updated_at"], json[:updated_at]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_blueprint_updated_data_invocable_by_round_trip
+  def test_feature_flags_flag_created_data_owner_round_trip
     fixture = {
-      "role_slugs" => [],
-      "organization_ids" => []
+      "email" => "stub",
+      "first_name" => nil,
+      "last_name" => nil
     }
-    model = WorkOS::AgentBlueprintUpdatedDataInvocableBy.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagCreatedDataOwner.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
+    assert_equal fixture["email"], json[:email]
+    assert_nil json[:first_name]
+    assert_nil json[:last_name]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_blueprint_updated_data_session_setting_round_trip
+  def test_feature_flags_flag_created_context_round_trip
     fixture = {
-      "max_age_seconds" => 1.0,
-      "access_token_ttl_seconds" => 1.0,
-      "refresh_token_ttl_seconds" => 1.0
+      "client_id" => "stub",
+      "actor" => {}
     }
-    model = WorkOS::AgentBlueprintUpdatedDataSessionSetting.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagCreatedContext.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
-    assert_equal fixture["max_age_seconds"], json[:max_age_seconds]
-    assert_equal fixture["access_token_ttl_seconds"], json[:access_token_ttl_seconds]
-    assert_equal fixture["refresh_token_ttl_seconds"], json[:refresh_token_ttl_seconds]
+    assert_equal fixture["client_id"], json[:client_id]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_instance_created_round_trip
+  def test_feature_flags_flag_created_context_actor_round_trip
     fixture = {
-      "object" => "event",
       "id" => "stub",
-      "event" => "agent.instance.created",
-      "data" => {},
-      "created_at" => "stub",
-      "context" => {}
+      "source" => "stub",
+      "name" => nil
     }
-    model = WorkOS::AgentInstanceCreated.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagCreatedContextActor.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
-    assert_equal fixture["created_at"], json[:created_at]
+    assert_nil json[:name]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_instance_created_data_round_trip
+  def test_feature_flags_flag_deleted_round_trip
     fixture = {
-      "object" => "agent_instance",
+      "object" => "event",
       "id" => "stub",
-      "agent_blueprint_id" => "stub",
-      "organization_id" => "stub",
-      "organization_membership_id" => nil,
-      "type" => "stub",
+      "event" => "feature_flags.flag.deleted",
+      "data" => {},
       "created_at" => "stub",
-      "updated_at" => "stub"
+      "context" => {}
     }
-    model = WorkOS::AgentInstanceCreatedData.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagDeleted.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
-    assert_equal fixture["agent_blueprint_id"], json[:agent_blueprint_id]
-    assert_equal fixture["organization_id"], json[:organization_id]
-    assert_nil json[:organization_membership_id]
     assert_equal fixture["created_at"], json[:created_at]
-    assert_equal fixture["updated_at"], json[:updated_at]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_instance_deleted_round_trip
+  def test_feature_flags_flag_deleted_data_round_trip
     fixture = {
-      "object" => "event",
+      "object" => "feature_flag",
       "id" => "stub",
-      "event" => "agent.instance.deleted",
-      "data" => {},
+      "environment_id" => "stub",
+      "slug" => "stub",
+      "name" => "stub",
+      "description" => nil,
+      "owner" => nil,
+      "tags" => [],
+      "enabled" => true,
+      "default_value" => true,
       "created_at" => "stub",
-      "context" => {}
+      "updated_at" => "stub"
     }
-    model = WorkOS::AgentInstanceDeleted.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagDeletedData.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
+    assert_equal fixture["environment_id"], json[:environment_id]
+    assert_equal fixture["slug"], json[:slug]
+    assert_equal fixture["name"], json[:name]
+    assert_nil json[:description]
+    assert_equal fixture["enabled"], json[:enabled]
+    assert_equal fixture["default_value"], json[:default_value]
     assert_equal fixture["created_at"], json[:created_at]
+    assert_equal fixture["updated_at"], json[:updated_at]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_instance_deleted_data_round_trip
+  def test_feature_flags_flag_deleted_data_owner_round_trip
     fixture = {
-      "object" => "agent_instance",
-      "id" => "stub",
-      "agent_blueprint_id" => "stub",
-      "organization_id" => "stub",
-      "organization_membership_id" => nil,
-      "type" => "stub",
-      "created_at" => "stub",
-      "updated_at" => "stub"
+      "email" => "stub",
+      "first_name" => nil,
+      "last_name" => nil
     }
-    model = WorkOS::AgentInstanceDeletedData.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagDeletedDataOwner.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
-    assert_equal fixture["id"], json[:id]
-    assert_equal fixture["agent_blueprint_id"], json[:agent_blueprint_id]
-    assert_equal fixture["organization_id"], json[:organization_id]
-    assert_nil json[:organization_membership_id]
-    assert_equal fixture["created_at"], json[:created_at]
-    assert_equal fixture["updated_at"], json[:updated_at]
+    assert_equal fixture["email"], json[:email]
+    assert_nil json[:first_name]
+    assert_nil json[:last_name]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_instance_session_created_round_trip
+  def test_feature_flags_flag_deleted_context_round_trip
     fixture = {
-      "object" => "event",
-      "id" => "stub",
-      "event" => "agent.instance.session.created",
-      "data" => {},
-      "created_at" => "stub",
-      "context" => {}
+      "client_id" => "stub",
+      "actor" => {}
     }
-    model = WorkOS::AgentInstanceSessionCreated.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagDeletedContext.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
-    assert_equal fixture["id"], json[:id]
-    assert_equal fixture["created_at"], json[:created_at]
+    assert_equal fixture["client_id"], json[:client_id]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_instance_session_created_data_round_trip
+  def test_feature_flags_flag_deleted_context_actor_round_trip
     fixture = {
-      "object" => "agent_instance_session",
       "id" => "stub",
-      "agent_instance_id" => "stub",
-      "organization_id" => "stub",
-      "expires_at" => "stub",
-      "revoked_at" => nil,
-      "created_at" => "stub",
-      "updated_at" => "stub",
-      "permission_slugs" => []
+      "source" => "stub",
+      "name" => nil
     }
-    model = WorkOS::AgentInstanceSessionCreatedData.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagDeletedContextActor.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
-    assert_equal fixture["agent_instance_id"], json[:agent_instance_id]
-    assert_equal fixture["organization_id"], json[:organization_id]
-    assert_equal fixture["expires_at"], json[:expires_at]
-    assert_nil json[:revoked_at]
-    assert_equal fixture["created_at"], json[:created_at]
-    assert_equal fixture["updated_at"], json[:updated_at]
+    assert_nil json[:name]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_instance_session_revoked_round_trip
+  def test_feature_flags_flag_rule_created_round_trip
     fixture = {
       "object" => "event",
       "id" => "stub",
-      "event" => "agent.instance.session.revoked",
+      "event" => "feature_flags.flag_rule.created",
       "data" => {},
       "created_at" => "stub",
       "context" => {}
     }
-    model = WorkOS::AgentInstanceSessionRevoked.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagRuleCreated.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
@@ -526,40 +2081,42 @@ class SharedModelRoundTripTest < Minitest::Test
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_instance_session_revoked_data_round_trip
+  def test_feature_flags_flag_rule_created_context_round_trip
+    fixture = {
+      "client_id" => "stub",
+      "actor" => {}
+    }
+    model = WorkOS::FeatureFlagsFlagRuleCreatedContext.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["client_id"], json[:client_id]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_feature_flags_flag_rule_created_context_actor_round_trip
     fixture = {
-      "object" => "agent_instance_session",
       "id" => "stub",
-      "agent_instance_id" => "stub",
-      "organization_id" => "stub",
-      "expires_at" => "stub",
-      "revoked_at" => nil,
-      "created_at" => "stub",
-      "updated_at" => "stub"
+      "source" => "stub",
+      "name" => nil
     }
-    model = WorkOS::AgentInstanceSessionRevokedData.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagRuleCreatedContextActor.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
-    assert_equal fixture["agent_instance_id"], json[:agent_instance_id]
-    assert_equal fixture["organization_id"], json[:organization_id]
-    assert_equal fixture["expires_at"], json[:expires_at]
-    assert_nil json[:revoked_at]
-    assert_equal fixture["created_at"], json[:created_at]
-    assert_equal fixture["updated_at"], json[:updated_at]
+    assert_nil json[:name]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_registration_claim_attempt_created_round_trip
+  def test_feature_flags_flag_rule_deleted_round_trip
     fixture = {
       "object" => "event",
       "id" => "stub",
-      "event" => "agent.registration.claim.attempt.created",
+      "event" => "feature_flags.flag_rule.deleted",
       "data" => {},
       "created_at" => "stub",
       "context" => {}
     }
-    model = WorkOS::AgentRegistrationClaimAttemptCreated.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagRuleDeleted.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
@@ -567,144 +2124,106 @@ class SharedModelRoundTripTest < Minitest::Test
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_registration_claim_attempt_created_data_round_trip
+  def test_feature_flags_flag_rule_deleted_context_round_trip
     fixture = {
-      "object" => "agent_registration_claim_attempt",
-      "id" => "stub",
-      "agent_registration_id" => "stub",
-      "agent_registration_claim_id" => "stub",
-      "login_hint" => "stub",
-      "expires_at" => "stub",
-      "created_at" => "stub",
-      "updated_at" => "stub"
+      "client_id" => "stub",
+      "actor" => {}
     }
-    model = WorkOS::AgentRegistrationClaimAttemptCreatedData.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagRuleDeletedContext.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
-    assert_equal fixture["id"], json[:id]
-    assert_equal fixture["agent_registration_id"], json[:agent_registration_id]
-    assert_equal fixture["agent_registration_claim_id"], json[:agent_registration_claim_id]
-    assert_equal fixture["login_hint"], json[:login_hint]
-    assert_equal fixture["expires_at"], json[:expires_at]
-    assert_equal fixture["created_at"], json[:created_at]
-    assert_equal fixture["updated_at"], json[:updated_at]
+    assert_equal fixture["client_id"], json[:client_id]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
-
-  def test_agent_registration_claim_completed_round_trip
-    fixture = {
-      "object" => "event",
-      "id" => "stub",
-      "event" => "agent.registration.claim.completed",
-      "data" => {},
-      "created_at" => "stub",
-      "context" => {}
+
+  def test_feature_flags_flag_rule_deleted_context_actor_round_trip
+    fixture = {
+      "id" => "stub",
+      "source" => "stub",
+      "name" => nil
     }
-    model = WorkOS::AgentRegistrationClaimCompleted.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagRuleDeletedContextActor.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
-    assert_equal fixture["created_at"], json[:created_at]
+    assert_nil json[:name]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_registration_claim_completed_data_round_trip
+  def test_feature_flags_flag_rule_updated_round_trip
     fixture = {
-      "object" => "agent_registration_claim",
+      "object" => "event",
       "id" => "stub",
-      "agent_registration_id" => "stub",
-      "completed_by_attempt_id" => "stub",
-      "claimed_by" => {},
-      "completed_at" => "stub",
+      "event" => "feature_flags.flag_rule.updated",
+      "data" => {},
       "created_at" => "stub",
-      "updated_at" => "stub"
+      "context" => {}
     }
-    model = WorkOS::AgentRegistrationClaimCompletedData.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagRuleUpdated.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
-    assert_equal fixture["agent_registration_id"], json[:agent_registration_id]
-    assert_equal fixture["completed_by_attempt_id"], json[:completed_by_attempt_id]
-    assert_equal fixture["completed_at"], json[:completed_at]
     assert_equal fixture["created_at"], json[:created_at]
-    assert_equal fixture["updated_at"], json[:updated_at]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_registration_claim_completed_data_claimed_by_round_trip
+  def test_feature_flags_flag_rule_updated_context_round_trip
     fixture = {
-      "user_id" => "stub",
-      "organization_id" => "stub"
+      "client_id" => "stub",
+      "actor" => {},
+      "previous_attributes" => {}
     }
-    model = WorkOS::AgentRegistrationClaimCompletedDataClaimedBy.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagRuleUpdatedContext.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
-    assert_equal fixture["user_id"], json[:user_id]
+    assert_equal fixture["client_id"], json[:client_id]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_registration_created_round_trip
+  def test_feature_flags_flag_rule_updated_context_actor_round_trip
     fixture = {
-      "object" => "event",
       "id" => "stub",
-      "event" => "agent.registration.created",
-      "data" => {},
-      "created_at" => "stub",
-      "context" => {}
+      "source" => "stub",
+      "name" => nil
     }
-    model = WorkOS::AgentRegistrationCreated.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagRuleUpdatedContextActor.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
-    assert_equal fixture["created_at"], json[:created_at]
+    assert_nil json[:name]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_registration_created_data_round_trip
+  def test_feature_flags_flag_rule_updated_context_previous_attribute_round_trip
     fixture = {
-      "object" => "agent_registration",
-      "id" => "stub",
-      "agent_identity" => {},
-      "organization_id" => "stub",
-      "status" => "stub",
-      "kind" => "stub",
-      "method" => "stub",
-      "created_at" => "stub",
-      "updated_at" => "stub"
+      "data" => {}
     }
-    model = WorkOS::AgentRegistrationCreatedData.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagRuleUpdatedContextPreviousAttribute.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
-    assert_equal fixture["id"], json[:id]
-    assert_equal fixture["organization_id"], json[:organization_id]
-    assert_equal fixture["created_at"], json[:created_at]
-    assert_equal fixture["updated_at"], json[:updated_at]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_registration_created_data_agent_identity_round_trip
+  def test_feature_flags_flag_rule_updated_context_previous_attribute_data_round_trip
     fixture = {
-      "object" => "agent_identity",
-      "id" => "stub",
-      "userland_user_id" => "stub"
+      "value" => true
     }
-    model = WorkOS::AgentRegistrationCreatedDataAgentIdentity.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagRuleUpdatedContextPreviousAttributeData.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
-    assert_equal fixture["id"], json[:id]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_registration_credential_issued_round_trip
+  def test_feature_flags_flag_updated_round_trip
     fixture = {
       "object" => "event",
       "id" => "stub",
-      "event" => "agent.registration.credential.issued",
+      "event" => "feature_flags.flag.updated",
       "data" => {},
       "created_at" => "stub",
       "context" => {}
     }
-    model = WorkOS::AgentRegistrationCredentialIssued.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagUpdated.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
@@ -712,116 +2231,128 @@ class SharedModelRoundTripTest < Minitest::Test
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_registration_credential_issued_data_round_trip
+  def test_feature_flags_flag_updated_data_round_trip
     fixture = {
-      "object" => "agent_registration_credential",
+      "object" => "feature_flag",
       "id" => "stub",
-      "agent_registration_id" => "stub",
-      "detail" => {},
+      "environment_id" => "stub",
+      "slug" => "stub",
+      "name" => "stub",
+      "description" => nil,
+      "owner" => nil,
+      "tags" => [],
+      "enabled" => true,
+      "default_value" => true,
       "created_at" => "stub",
       "updated_at" => "stub"
     }
-    model = WorkOS::AgentRegistrationCredentialIssuedData.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagUpdatedData.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
-    assert_equal fixture["agent_registration_id"], json[:agent_registration_id]
+    assert_equal fixture["environment_id"], json[:environment_id]
+    assert_equal fixture["slug"], json[:slug]
+    assert_equal fixture["name"], json[:name]
+    assert_nil json[:description]
+    assert_equal fixture["enabled"], json[:enabled]
+    assert_equal fixture["default_value"], json[:default_value]
     assert_equal fixture["created_at"], json[:created_at]
     assert_equal fixture["updated_at"], json[:updated_at]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_registration_credential_issued_data_detail_round_trip
+  def test_feature_flags_flag_updated_data_owner_round_trip
     fixture = {
-      "kind" => "api_key",
-      "api_key_id" => "stub"
+      "email" => "stub",
+      "first_name" => nil,
+      "last_name" => nil
     }
-    model = WorkOS::AgentRegistrationCredentialIssuedDataDetail.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagUpdatedDataOwner.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
-    assert_equal fixture["api_key_id"], json[:api_key_id]
+    assert_equal fixture["email"], json[:email]
+    assert_nil json[:first_name]
+    assert_nil json[:last_name]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_access_token_agent_registration_credential_issued_data_detail_round_trip
+  def test_feature_flags_flag_updated_context_round_trip
     fixture = {
-      "kind" => "access_token",
-      "jti" => "stub",
-      "expires_at" => "stub"
+      "client_id" => "stub",
+      "actor" => {},
+      "previous_attributes" => {}
     }
-    model = WorkOS::AccessTokenAgentRegistrationCredentialIssuedDataDetail.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagUpdatedContext.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
-    assert_equal fixture["jti"], json[:jti]
+    assert_equal fixture["client_id"], json[:client_id]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_registration_deleted_round_trip
+  def test_feature_flags_flag_updated_context_actor_round_trip
     fixture = {
-      "object" => "event",
       "id" => "stub",
-      "event" => "agent.registration.deleted",
-      "data" => {},
-      "created_at" => "stub",
-      "context" => {}
+      "source" => "stub",
+      "name" => nil
     }
-    model = WorkOS::AgentRegistrationDeleted.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagUpdatedContextActor.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
-    assert_equal fixture["created_at"], json[:created_at]
+    assert_nil json[:name]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_registration_deleted_data_round_trip
+  def test_feature_flags_flag_updated_context_previous_attribute_round_trip
     fixture = {
-      "agent_registration_id" => "stub"
+      "data" => {}
     }
-    model = WorkOS::AgentRegistrationDeletedData.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagUpdatedContextPreviousAttribute.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
-    assert_equal fixture["agent_registration_id"], json[:agent_registration_id]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_registration_expired_round_trip
+  def test_feature_flags_flag_updated_context_previous_attribute_data_round_trip
     fixture = {
-      "object" => "event",
-      "id" => "stub",
-      "event" => "agent.registration.expired",
-      "data" => {},
-      "created_at" => "stub",
-      "context" => {}
+      "name" => "stub",
+      "description" => nil,
+      "tags" => [],
+      "owner" => nil,
+      "enabled" => true,
+      "default_value" => true
     }
-    model = WorkOS::AgentRegistrationExpired.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagUpdatedContextPreviousAttributeData.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
-    assert_equal fixture["id"], json[:id]
-    assert_equal fixture["created_at"], json[:created_at]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_registration_expired_data_round_trip
+  def test_feature_flags_flag_updated_context_previous_attribute_data_owner_round_trip
     fixture = {
-      "agent_registration_id" => "stub"
+      "email" => "stub",
+      "first_name" => nil,
+      "last_name" => nil
     }
-    model = WorkOS::AgentRegistrationExpiredData.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagUpdatedContextPreviousAttributeDataOwner.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
-    assert_equal fixture["agent_registration_id"], json[:agent_registration_id]
+    assert_equal fixture["email"], json[:email]
+    assert_nil json[:first_name]
+    assert_nil json[:last_name]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_registration_organization_switched_round_trip
+  def test_feature_flags_flag_target_created_round_trip
     fixture = {
       "object" => "event",
       "id" => "stub",
-      "event" => "agent.registration.organization.switched",
+      "event" => "feature_flags.flag_target.created",
       "data" => {},
       "created_at" => "stub",
       "context" => {}
     }
-    model = WorkOS::AgentRegistrationOrganizationSwitched.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagTargetCreated.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
@@ -829,59 +2360,42 @@ class SharedModelRoundTripTest < Minitest::Test
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_registration_organization_switched_data_round_trip
+  def test_feature_flags_flag_target_created_context_round_trip
     fixture = {
-      "agent_registration_id" => "stub",
-      "from_organization_id" => "stub",
-      "to_organization_id" => "stub"
+      "client_id" => "stub",
+      "actor" => {}
     }
-    model = WorkOS::AgentRegistrationOrganizationSwitchedData.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagTargetCreatedContext.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
-    assert_equal fixture["agent_registration_id"], json[:agent_registration_id]
-    assert_equal fixture["from_organization_id"], json[:from_organization_id]
-    assert_equal fixture["to_organization_id"], json[:to_organization_id]
+    assert_equal fixture["client_id"], json[:client_id]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_registration_refreshed_round_trip
+  def test_feature_flags_flag_target_created_context_actor_round_trip
     fixture = {
-      "object" => "event",
       "id" => "stub",
-      "event" => "agent.registration.refreshed",
-      "data" => {},
-      "created_at" => "stub",
-      "context" => {}
+      "source" => "stub",
+      "name" => nil
     }
-    model = WorkOS::AgentRegistrationRefreshed.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagTargetCreatedContextActor.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
-    assert_equal fixture["created_at"], json[:created_at]
-    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
-  end
-
-  def test_agent_registration_refreshed_data_round_trip
-    fixture = {
-      "agent_registration_id" => "stub"
-    }
-    model = WorkOS::AgentRegistrationRefreshedData.new(fixture.to_json)
-    json = model.to_h
-    assert_kind_of Hash, json
-    assert_equal fixture["agent_registration_id"], json[:agent_registration_id]
+    assert_nil json[:name]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_registration_revoked_round_trip
+  def test_feature_flags_flag_target_deleted_round_trip
     fixture = {
       "object" => "event",
       "id" => "stub",
-      "event" => "agent.registration.revoked",
+      "event" => "feature_flags.flag_target.deleted",
       "data" => {},
       "created_at" => "stub",
       "context" => {}
     }
-    model = WorkOS::AgentRegistrationRevoked.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagTargetDeleted.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
     assert_equal fixture["id"], json[:id]
@@ -889,14 +2403,29 @@ class SharedModelRoundTripTest < Minitest::Test
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_agent_registration_revoked_data_round_trip
+  def test_feature_flags_flag_target_deleted_context_round_trip
     fixture = {
-      "agent_registration_id" => "stub"
+      "client_id" => "stub",
+      "actor" => {}
     }
-    model = WorkOS::AgentRegistrationRevokedData.new(fixture.to_json)
+    model = WorkOS::FeatureFlagsFlagTargetDeletedContext.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
-    assert_equal fixture["agent_registration_id"], json[:agent_registration_id]
+    assert_equal fixture["client_id"], json[:client_id]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_feature_flags_flag_target_deleted_context_actor_round_trip
+    fixture = {
+      "id" => "stub",
+      "source" => "stub",
+      "name" => nil
+    }
+    model = WorkOS::FeatureFlagsFlagTargetDeletedContextActor.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_nil json[:name]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
@@ -1451,6 +2980,56 @@ class SharedModelRoundTripTest < Minitest::Test
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
+  def test_auth_method_mismatch_error_round_trip
+    fixture = {
+      "code" => "auth_method_mismatch",
+      "message" => "stub"
+    }
+    model = WorkOS::AuthMethodMismatchError.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_data_integration_access_token_response_with_access_token_round_trip
+    fixture = {
+      "active" => true,
+      "access_token" => {}
+    }
+    model = WorkOS::DataIntegrationAccessTokenResponseWithAccessToken.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_data_integration_access_token_response_with_access_token_access_token_round_trip
+    fixture = {
+      "object" => "access_token",
+      "access_token" => "stub",
+      "expires_at" => nil,
+      "scopes" => [],
+      "missing_scopes" => []
+    }
+    model = WorkOS::DataIntegrationAccessTokenResponseWithAccessTokenAccessToken.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["access_token"], json[:access_token]
+    assert_nil json[:expires_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_data_integration_access_token_response_with_error_round_trip
+    fixture = {
+      "active" => false,
+      "error" => "stub"
+    }
+    model = WorkOS::DataIntegrationAccessTokenResponseWithError.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
   def test_account_selection_required_error_round_trip
     fixture = {
       "code" => "account_selection_required",
@@ -1463,15 +3042,63 @@ class SharedModelRoundTripTest < Minitest::Test
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
-  def test_auth_method_mismatch_error_round_trip
+  def test_oauth_data_integration_vended_credential_round_trip
     fixture = {
-      "code" => "auth_method_mismatch",
-      "message" => "stub"
+      "object" => "credential",
+      "auth_method" => "oauth",
+      "value" => "stub",
+      "expires_at" => nil,
+      "scopes" => [],
+      "missing_scopes" => [],
+      "metadata" => {},
+      "config" => {}
     }
-    model = WorkOS::AuthMethodMismatchError.new(fixture.to_json)
+    model = WorkOS::OAuthDataIntegrationVendedCredential.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["value"], json[:value]
+    assert_nil json[:expires_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_client_credentials_data_integration_vended_credential_round_trip
+    fixture = {
+      "object" => "credential",
+      "auth_method" => "client_credentials",
+      "value" => "stub",
+      "expires_at" => nil,
+      "scopes" => [],
+      "missing_scopes" => [],
+      "metadata" => {},
+      "config" => {}
+    }
+    model = WorkOS::ClientCredentialsDataIntegrationVendedCredential.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["value"], json[:value]
+    assert_nil json[:expires_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_data_integration_credentials_response_with_credential_round_trip
+    fixture = {
+      "active" => true,
+      "credential" => {}
+    }
+    model = WorkOS::DataIntegrationCredentialsResponseWithCredential.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_data_integration_credentials_response_with_error_round_trip
+    fixture = {
+      "active" => false,
+      "error" => "stub"
+    }
+    model = WorkOS::DataIntegrationCredentialsResponseWithError.new(fixture.to_json)
     json = model.to_h
     assert_kind_of Hash, json
-    assert_equal fixture["message"], json[:message]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
@@ -1513,4 +3140,20 @@ class SharedModelRoundTripTest < Minitest::Test
     assert_equal fixture["id"], json[:id]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
+
+  def test_sso_required_oauth_error_body_with_connection_ids_list_email_pending_authentication_token_round_trip
+    fixture = {
+      "error" => "sso_required",
+      "error_description" => "stub",
+      "connection_ids" => [],
+      "email" => "stub",
+      "pending_authentication_token" => "stub"
+    }
+    model = WorkOS::SSORequiredOAuthErrorBodyWithConnectionIdsListEmailPendingAuthenticationToken.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error_description"], json[:error_description]
+    assert_equal fixture["email"], json[:email]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
 end