From a3b0ccd784c1235e3ba5b13eebd9b66ed570f40b Mon Sep 17 00:00:00 2001 From: "workos-sdk-automation[bot]" <255426317+workos-sdk-automation[bot]@users.noreply.github.com> Date: Thu, 2 Jul 2026 14:11:26 +0000 Subject: [PATCH 1/4] feat(user_management): Add user management operations and models --- lib/workos/user_management.rb | 83 ++++++++++++- ...ation_code_session_authenticate_request.rb | 7 +- .../create_magic_code_and_return.rb | 16 ++- lib/workos/user_management/create_user.rb | 9 ++ .../password_session_authenticate_request.rb | 10 +- .../send_radar_sms_challenge.rb | 31 +++++ .../send_radar_sms_challenge_response.rb | 22 ++++ .../user_management/user_create_response.rb | 7 ++ ...tion_code_session_authenticate_request.rbi | 6 + rbi/workos/create_magic_code_and_return.rbi | 24 ++++ rbi/workos/create_user.rbi | 18 +++ ...nd_magic_auth_code_and_return_response.rbi | 24 ++++ .../password_session_authenticate_request.rbi | 12 ++ rbi/workos/send_radar_sms_challenge.rbi | 48 +++++++ .../send_radar_sms_challenge_response.rbi | 30 +++++ rbi/workos/user_create_response.rbi | 24 ++++ rbi/workos/user_management.rbi | 30 ++++- test/workos/test_user_management.rb | 8 ++ .../test_user_management_model_round_trip.rb | 117 +++++++++++++++++- 19 files changed, 505 insertions(+), 21 deletions(-) create mode 100644 lib/workos/user_management/send_radar_sms_challenge.rb create mode 100644 lib/workos/user_management/send_radar_sms_challenge_response.rb create mode 100644 lib/workos/user_management/user_create_response.rb create mode 100644 rbi/workos/magic_auth_send_magic_auth_code_and_return_response.rbi create mode 100644 rbi/workos/send_radar_sms_challenge.rbi create mode 100644 rbi/workos/send_radar_sms_challenge_response.rbi create mode 100644 rbi/workos/user_create_response.rbi diff --git a/lib/workos/user_management.rb b/lib/workos/user_management.rb index 44f06c1d..6f6705f9 100644 --- a/lib/workos/user_management.rb +++ b/lib/workos/user_management.rb @@ -53,12 +53,17 @@ def get_jwks( # @param ip_address [String, nil] The IP address of the user's request. # @param device_id [String, nil] A unique identifier for the device. # @param user_agent [String, nil] The user agent string from the user's browser. + # @param signals_id [String, nil] An optional Radar signals ID to correlate client-side signals with this authentication attempt. # @param email [String, nil] The user's email address. # @param password [String, nil] The user's password. + # @param radar_auth_attempt_id [String, nil] The ID of an existing Radar authentication attempt to associate with this authentication. # @param refresh_token [String, nil] The refresh token to exchange for new tokens. # @param organization_id [String, nil] The ID of the organization to scope the session to. # @param pending_authentication_token [String, nil] The pending authentication token from a previous authentication attempt. # @param authentication_challenge_id [String, nil] The ID of the MFA authentication challenge. + # @param radar_challenge_id [String, nil] The ID of the Radar email challenge being verified. + # @param verification_id [String, nil] The ID of the Radar SMS verification being confirmed. + # @param phone_number [String, nil] The phone number the Radar SMS challenge was sent to. # @param device_code [String, nil] The device verification code. # @param request_options [Hash] (see WorkOS::Types::RequestOptions) # @return [WorkOS::AuthenticateResponse] @@ -72,12 +77,17 @@ def create_authenticate( ip_address: nil, device_id: nil, user_agent: nil, + signals_id: nil, email: nil, password: nil, + radar_auth_attempt_id: nil, refresh_token: nil, organization_id: nil, pending_authentication_token: nil, authentication_challenge_id: nil, + radar_challenge_id: nil, + verification_id: nil, + phone_number: nil, device_code: nil, request_options: {} ) @@ -91,12 +101,17 @@ def create_authenticate( "ip_address" => ip_address, "device_id" => device_id, "user_agent" => user_agent, + "signals_id" => signals_id, "email" => email, "password" => password, + "radar_auth_attempt_id" => radar_auth_attempt_id, "refresh_token" => refresh_token, "organization_id" => organization_id, "pending_authentication_token" => pending_authentication_token, "authentication_challenge_id" => authentication_challenge_id, + "radar_challenge_id" => radar_challenge_id, + "verification_id" => verification_id, + "phone_number" => phone_number, "device_code" => device_code }.compact response = @client.request( @@ -430,6 +445,41 @@ def create_device( result end + # Send a Radar SMS challenge + # @param user_id [String] The ID of the user to send the SMS challenge to. + # @param pending_authentication_token [String] The pending authentication token from a previous authentication attempt that triggered the Radar challenge. + # @param phone_number [String] The phone number to send the SMS verification code to. + # @param ip_address [String, nil] The IP address of the user's request. + # @param user_agent [String, nil] The user agent string from the user's request. + # @param request_options [Hash] (see WorkOS::Types::RequestOptions) + # @return [WorkOS::SendRadarSmsChallengeResponse] + def create_radar_challenge( + user_id:, + pending_authentication_token:, + phone_number:, + ip_address: nil, + user_agent: nil, + request_options: {} + ) + body = { + "user_id" => user_id, + "pending_authentication_token" => pending_authentication_token, + "phone_number" => phone_number, + "ip_address" => ip_address, + "user_agent" => user_agent + }.compact + response = @client.request( + method: :post, + path: "/user_management/radar_challenges", + auth: true, + body: body, + request_options: request_options + ) + result = WorkOS::SendRadarSmsChallengeResponse.new(response.body) + result.last_response = WorkOS::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"]) + result + end + # Revoke Session # @param session_id [String] The ID of the session to revoke. This can be extracted from the `sid` claim of the access token. # @param request_options [Hash] (see WorkOS::Types::RequestOptions) @@ -669,9 +719,12 @@ def list_users( # @param email_verified [Boolean, nil] Whether the user's email has been verified. # @param metadata [Hash{String => String}, nil] Object containing metadata key/value pairs associated with the user. # @param external_id [String, nil] The external ID of the user. + # @param ip_address [String, nil] The IP address of the user's request. + # @param user_agent [String, nil] The user agent string from the user's request. + # @param signals_id [String, nil] An optional Radar signals ID to correlate client-side signals with this request. # @param password [WorkOS::UserManagement::PasswordPlaintext, WorkOS::UserManagement::PasswordHashed, nil] Identifies the password. # @param request_options [Hash] (see WorkOS::Types::RequestOptions) - # @return [WorkOS::User] + # @return [WorkOS::UserCreateResponse] def create_user( email:, first_name: nil, @@ -680,6 +733,9 @@ def create_user( email_verified: nil, metadata: nil, external_id: nil, + ip_address: nil, + user_agent: nil, + signals_id: nil, password: nil, request_options: {} ) @@ -690,7 +746,10 @@ def create_user( "name" => name, "email_verified" => email_verified, "metadata" => metadata, - "external_id" => external_id + "external_id" => external_id, + "ip_address" => ip_address, + "user_agent" => user_agent, + "signals_id" => signals_id }.compact if password case password @@ -710,7 +769,7 @@ def create_user( body: body, request_options: request_options ) - result = WorkOS::User.new(response.body) + result = WorkOS::UserCreateResponse.new(response.body) result.last_response = WorkOS::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"]) result end @@ -1220,16 +1279,28 @@ def update_jwt_template( # Create a Magic Auth code # @param email [String] The email address to send the magic code to. # @param invitation_token [String, nil] The invitation token to associate with this magic code. + # @param ip_address [String, nil] The IP address of the user's request. + # @param user_agent [String, nil] The user agent string from the user's request. + # @param radar_auth_attempt_id [String, nil] The ID of an existing Radar authentication attempt to associate with this request. + # @param signals_id [String, nil] An optional Radar signals ID to correlate client-side signals with this request. # @param request_options [Hash] (see WorkOS::Types::RequestOptions) - # @return [WorkOS::MagicAuth] + # @return [WorkOS::MagicAuthSendMagicAuthCodeAndReturnResponse] def create_magic_auth( email:, invitation_token: nil, + ip_address: nil, + user_agent: nil, + radar_auth_attempt_id: nil, + signals_id: nil, request_options: {} ) body = { "email" => email, - "invitation_token" => invitation_token + "invitation_token" => invitation_token, + "ip_address" => ip_address, + "user_agent" => user_agent, + "radar_auth_attempt_id" => radar_auth_attempt_id, + "signals_id" => signals_id }.compact response = @client.request( method: :post, @@ -1238,7 +1309,7 @@ def create_magic_auth( body: body, request_options: request_options ) - result = WorkOS::MagicAuth.new(response.body) + result = WorkOS::MagicAuthSendMagicAuthCodeAndReturnResponse.new(response.body) result.last_response = WorkOS::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"]) result end diff --git a/lib/workos/user_management/authorization_code_session_authenticate_request.rb b/lib/workos/user_management/authorization_code_session_authenticate_request.rb index 76f02f11..ad47db5e 100644 --- a/lib/workos/user_management/authorization_code_session_authenticate_request.rb +++ b/lib/workos/user_management/authorization_code_session_authenticate_request.rb @@ -13,7 +13,8 @@ class AuthorizationCodeSessionAuthenticateRequest < WorkOS::Types::BaseModel invitation_token: :invitation_token, ip_address: :ip_address, device_id: :device_id, - user_agent: :user_agent + user_agent: :user_agent, + signals_id: :signals_id }.freeze attr_accessor \ @@ -25,7 +26,8 @@ class AuthorizationCodeSessionAuthenticateRequest < WorkOS::Types::BaseModel :invitation_token, :ip_address, :device_id, - :user_agent + :user_agent, + :signals_id def initialize(json) hash = self.class.normalize(json) @@ -38,6 +40,7 @@ def initialize(json) @ip_address = hash[:ip_address] @device_id = hash[:device_id] @user_agent = hash[:user_agent] + @signals_id = hash[:signals_id] end end end diff --git a/lib/workos/user_management/create_magic_code_and_return.rb b/lib/workos/user_management/create_magic_code_and_return.rb index fcc683c9..d55d6f59 100644 --- a/lib/workos/user_management/create_magic_code_and_return.rb +++ b/lib/workos/user_management/create_magic_code_and_return.rb @@ -6,17 +6,29 @@ module WorkOS class CreateMagicCodeAndReturn < WorkOS::Types::BaseModel HASH_ATTRS = { email: :email, - invitation_token: :invitation_token + invitation_token: :invitation_token, + ip_address: :ip_address, + user_agent: :user_agent, + radar_auth_attempt_id: :radar_auth_attempt_id, + signals_id: :signals_id }.freeze attr_accessor \ :email, - :invitation_token + :invitation_token, + :ip_address, + :user_agent, + :radar_auth_attempt_id, + :signals_id def initialize(json) hash = self.class.normalize(json) @email = hash[:email] @invitation_token = hash[:invitation_token] + @ip_address = hash[:ip_address] + @user_agent = hash[:user_agent] + @radar_auth_attempt_id = hash[:radar_auth_attempt_id] + @signals_id = hash[:signals_id] end end end diff --git a/lib/workos/user_management/create_user.rb b/lib/workos/user_management/create_user.rb index fb85a6c6..f2b3e9f2 100644 --- a/lib/workos/user_management/create_user.rb +++ b/lib/workos/user_management/create_user.rb @@ -12,6 +12,9 @@ class CreateUser < WorkOS::Types::BaseModel email_verified: :email_verified, metadata: :metadata, external_id: :external_id, + ip_address: :ip_address, + user_agent: :user_agent, + signals_id: :signals_id, password: :password, password_hash: :password_hash, password_hash_type: :password_hash_type @@ -25,6 +28,9 @@ class CreateUser < WorkOS::Types::BaseModel :email_verified, :metadata, :external_id, + :ip_address, + :user_agent, + :signals_id, :password, :password_hash, :password_hash_type @@ -38,6 +44,9 @@ def initialize(json) @email_verified = hash[:email_verified] @metadata = hash[:metadata] || {} @external_id = hash[:external_id] + @ip_address = hash[:ip_address] + @user_agent = hash[:user_agent] + @signals_id = hash[:signals_id] @password = hash[:password] @password_hash = hash[:password_hash] @password_hash_type = hash[:password_hash_type] diff --git a/lib/workos/user_management/password_session_authenticate_request.rb b/lib/workos/user_management/password_session_authenticate_request.rb index f43f7970..2dbf9fb4 100644 --- a/lib/workos/user_management/password_session_authenticate_request.rb +++ b/lib/workos/user_management/password_session_authenticate_request.rb @@ -13,7 +13,9 @@ class PasswordSessionAuthenticateRequest < WorkOS::Types::BaseModel invitation_token: :invitation_token, ip_address: :ip_address, device_id: :device_id, - user_agent: :user_agent + user_agent: :user_agent, + signals_id: :signals_id, + radar_auth_attempt_id: :radar_auth_attempt_id }.freeze attr_accessor \ @@ -25,7 +27,9 @@ class PasswordSessionAuthenticateRequest < WorkOS::Types::BaseModel :invitation_token, :ip_address, :device_id, - :user_agent + :user_agent, + :signals_id, + :radar_auth_attempt_id def initialize(json) hash = self.class.normalize(json) @@ -38,6 +42,8 @@ def initialize(json) @ip_address = hash[:ip_address] @device_id = hash[:device_id] @user_agent = hash[:user_agent] + @signals_id = hash[:signals_id] + @radar_auth_attempt_id = hash[:radar_auth_attempt_id] end end end diff --git a/lib/workos/user_management/send_radar_sms_challenge.rb b/lib/workos/user_management/send_radar_sms_challenge.rb new file mode 100644 index 00000000..981ff14e --- /dev/null +++ b/lib/workos/user_management/send_radar_sms_challenge.rb @@ -0,0 +1,31 @@ +# frozen_string_literal: true + +# This file is auto-generated by oagen. Do not edit. + +module WorkOS + class SendRadarSmsChallenge < WorkOS::Types::BaseModel + HASH_ATTRS = { + user_id: :user_id, + pending_authentication_token: :pending_authentication_token, + phone_number: :phone_number, + ip_address: :ip_address, + user_agent: :user_agent + }.freeze + + attr_accessor \ + :user_id, + :pending_authentication_token, + :phone_number, + :ip_address, + :user_agent + + def initialize(json) + hash = self.class.normalize(json) + @user_id = hash[:user_id] + @pending_authentication_token = hash[:pending_authentication_token] + @phone_number = hash[:phone_number] + @ip_address = hash[:ip_address] + @user_agent = hash[:user_agent] + end + end +end diff --git a/lib/workos/user_management/send_radar_sms_challenge_response.rb b/lib/workos/user_management/send_radar_sms_challenge_response.rb new file mode 100644 index 00000000..02c75097 --- /dev/null +++ b/lib/workos/user_management/send_radar_sms_challenge_response.rb @@ -0,0 +1,22 @@ +# frozen_string_literal: true + +# This file is auto-generated by oagen. Do not edit. + +module WorkOS + class SendRadarSmsChallengeResponse < WorkOS::Types::BaseModel + HASH_ATTRS = { + verification_id: :verification_id, + phone_number: :phone_number + }.freeze + + attr_accessor \ + :verification_id, + :phone_number + + def initialize(json) + hash = self.class.normalize(json) + @verification_id = hash[:verification_id] + @phone_number = hash[:phone_number] + end + end +end diff --git a/lib/workos/user_management/user_create_response.rb b/lib/workos/user_management/user_create_response.rb new file mode 100644 index 00000000..83c97def --- /dev/null +++ b/lib/workos/user_management/user_create_response.rb @@ -0,0 +1,7 @@ +# frozen_string_literal: true + +# This file is auto-generated by oagen. Do not edit. + +module WorkOS + UserCreateResponse = MagicAuthSendMagicAuthCodeAndReturnResponse +end diff --git a/rbi/workos/authorization_code_session_authenticate_request.rbi b/rbi/workos/authorization_code_session_authenticate_request.rbi index 834f0cd8..62907bf3 100644 --- a/rbi/workos/authorization_code_session_authenticate_request.rbi +++ b/rbi/workos/authorization_code_session_authenticate_request.rbi @@ -63,6 +63,12 @@ module WorkOS sig { params(value: T.nilable(String)).returns(T.nilable(String)) } def user_agent=(value); end + sig { returns(T.nilable(String)) } + def signals_id; end + + sig { params(value: T.nilable(String)).returns(T.nilable(String)) } + def signals_id=(value); end + sig { returns(T::Hash[Symbol, T.untyped]) } def to_h; end diff --git a/rbi/workos/create_magic_code_and_return.rbi b/rbi/workos/create_magic_code_and_return.rbi index 55e625c4..fb22e111 100644 --- a/rbi/workos/create_magic_code_and_return.rbi +++ b/rbi/workos/create_magic_code_and_return.rbi @@ -21,6 +21,30 @@ module WorkOS sig { params(value: T.nilable(String)).returns(T.nilable(String)) } def invitation_token=(value); end + sig { returns(T.nilable(String)) } + def ip_address; end + + sig { params(value: T.nilable(String)).returns(T.nilable(String)) } + def ip_address=(value); end + + sig { returns(T.nilable(String)) } + def user_agent; end + + sig { params(value: T.nilable(String)).returns(T.nilable(String)) } + def user_agent=(value); end + + sig { returns(T.nilable(String)) } + def radar_auth_attempt_id; end + + sig { params(value: T.nilable(String)).returns(T.nilable(String)) } + def radar_auth_attempt_id=(value); end + + sig { returns(T.nilable(String)) } + def signals_id; end + + sig { params(value: T.nilable(String)).returns(T.nilable(String)) } + def signals_id=(value); end + sig { returns(T::Hash[Symbol, T.untyped]) } def to_h; end diff --git a/rbi/workos/create_user.rbi b/rbi/workos/create_user.rbi index 37dd7d18..06b8a4f9 100644 --- a/rbi/workos/create_user.rbi +++ b/rbi/workos/create_user.rbi @@ -51,6 +51,24 @@ module WorkOS sig { params(value: T.nilable(String)).returns(T.nilable(String)) } def external_id=(value); end + sig { returns(T.nilable(String)) } + def ip_address; end + + sig { params(value: T.nilable(String)).returns(T.nilable(String)) } + def ip_address=(value); end + + sig { returns(T.nilable(String)) } + def user_agent; end + + sig { params(value: T.nilable(String)).returns(T.nilable(String)) } + def user_agent=(value); end + + sig { returns(T.nilable(String)) } + def signals_id; end + + sig { params(value: T.nilable(String)).returns(T.nilable(String)) } + def signals_id=(value); end + sig { returns(T.nilable(String)) } def password; end diff --git a/rbi/workos/magic_auth_send_magic_auth_code_and_return_response.rbi b/rbi/workos/magic_auth_send_magic_auth_code_and_return_response.rbi new file mode 100644 index 00000000..8b746ee1 --- /dev/null +++ b/rbi/workos/magic_auth_send_magic_auth_code_and_return_response.rbi @@ -0,0 +1,24 @@ +# frozen_string_literal: true + +# This file is auto-generated by oagen. Do not edit. + +# typed: strong + +module WorkOS + class MagicAuthSendMagicAuthCodeAndReturnResponse + sig { params(json: T.any(String, T::Hash[Symbol, T.untyped])).void } + def initialize(json); end + + sig { returns(T.nilable(String)) } + def radar_auth_attempt_id; end + + sig { params(value: T.nilable(String)).returns(T.nilable(String)) } + def radar_auth_attempt_id=(value); end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h; end + + sig { params(args: T.untyped).returns(String) } + def to_json(*args); end + end +end diff --git a/rbi/workos/password_session_authenticate_request.rbi b/rbi/workos/password_session_authenticate_request.rbi index bcb0f23e..ad5d1ab6 100644 --- a/rbi/workos/password_session_authenticate_request.rbi +++ b/rbi/workos/password_session_authenticate_request.rbi @@ -63,6 +63,18 @@ module WorkOS sig { params(value: T.nilable(String)).returns(T.nilable(String)) } def user_agent=(value); end + sig { returns(T.nilable(String)) } + def signals_id; end + + sig { params(value: T.nilable(String)).returns(T.nilable(String)) } + def signals_id=(value); end + + sig { returns(T.nilable(String)) } + def radar_auth_attempt_id; end + + sig { params(value: T.nilable(String)).returns(T.nilable(String)) } + def radar_auth_attempt_id=(value); end + sig { returns(T::Hash[Symbol, T.untyped]) } def to_h; end diff --git a/rbi/workos/send_radar_sms_challenge.rbi b/rbi/workos/send_radar_sms_challenge.rbi new file mode 100644 index 00000000..b2998aa5 --- /dev/null +++ b/rbi/workos/send_radar_sms_challenge.rbi @@ -0,0 +1,48 @@ +# frozen_string_literal: true + +# This file is auto-generated by oagen. Do not edit. + +# typed: strong + +module WorkOS + class SendRadarSmsChallenge + sig { params(json: T.any(String, T::Hash[Symbol, T.untyped])).void } + def initialize(json); end + + sig { returns(String) } + def user_id; end + + sig { params(value: String).returns(String) } + def user_id=(value); end + + sig { returns(String) } + def pending_authentication_token; end + + sig { params(value: String).returns(String) } + def pending_authentication_token=(value); end + + sig { returns(String) } + def phone_number; end + + sig { params(value: String).returns(String) } + def phone_number=(value); end + + sig { returns(T.nilable(String)) } + def ip_address; end + + sig { params(value: T.nilable(String)).returns(T.nilable(String)) } + def ip_address=(value); end + + sig { returns(T.nilable(String)) } + def user_agent; end + + sig { params(value: T.nilable(String)).returns(T.nilable(String)) } + def user_agent=(value); end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h; end + + sig { params(args: T.untyped).returns(String) } + def to_json(*args); end + end +end diff --git a/rbi/workos/send_radar_sms_challenge_response.rbi b/rbi/workos/send_radar_sms_challenge_response.rbi new file mode 100644 index 00000000..77f8fa5c --- /dev/null +++ b/rbi/workos/send_radar_sms_challenge_response.rbi @@ -0,0 +1,30 @@ +# frozen_string_literal: true + +# This file is auto-generated by oagen. Do not edit. + +# typed: strong + +module WorkOS + class SendRadarSmsChallengeResponse + sig { params(json: T.any(String, T::Hash[Symbol, T.untyped])).void } + def initialize(json); end + + sig { returns(String) } + def verification_id; end + + sig { params(value: String).returns(String) } + def verification_id=(value); end + + sig { returns(String) } + def phone_number; end + + sig { params(value: String).returns(String) } + def phone_number=(value); end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h; end + + sig { params(args: T.untyped).returns(String) } + def to_json(*args); end + end +end diff --git a/rbi/workos/user_create_response.rbi b/rbi/workos/user_create_response.rbi new file mode 100644 index 00000000..727fd387 --- /dev/null +++ b/rbi/workos/user_create_response.rbi @@ -0,0 +1,24 @@ +# frozen_string_literal: true + +# This file is auto-generated by oagen. Do not edit. + +# typed: strong + +module WorkOS + class UserCreateResponse + sig { params(json: T.any(String, T::Hash[Symbol, T.untyped])).void } + def initialize(json); end + + sig { returns(T.nilable(String)) } + def radar_auth_attempt_id; end + + sig { params(value: T.nilable(String)).returns(T.nilable(String)) } + def radar_auth_attempt_id=(value); end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h; end + + sig { params(args: T.untyped).returns(String) } + def to_json(*args); end + end +end diff --git a/rbi/workos/user_management.rbi b/rbi/workos/user_management.rbi index c0c9437f..9cc2c652 100644 --- a/rbi/workos/user_management.rbi +++ b/rbi/workos/user_management.rbi @@ -56,10 +56,11 @@ module WorkOS ip_address: T.nilable(String), device_id: T.nilable(String), user_agent: T.nilable(String), + signals_id: T.nilable(String), request_options: T::Hash[Symbol, T.untyped] ).returns(WorkOS::AuthenticateResponse) end - def create_authenticate(client_id:, grant_type:, code:, client_secret:, code_verifier:, invitation_token:, ip_address:, device_id:, user_agent:, request_options:); end + def create_authenticate(client_id:, grant_type:, code:, client_secret:, code_verifier:, invitation_token:, ip_address:, device_id:, user_agent:, signals_id:, request_options:); end sig do params( @@ -69,6 +70,18 @@ module WorkOS end def create_device(client_id:, request_options:); end + sig do + params( + user_id: String, + pending_authentication_token: String, + phone_number: String, + ip_address: T.nilable(String), + user_agent: T.nilable(String), + request_options: T::Hash[Symbol, T.untyped] + ).returns(WorkOS::SendRadarSmsChallengeResponse) + end + def create_radar_challenge(user_id:, pending_authentication_token:, phone_number:, ip_address:, user_agent:, request_options:); end + sig do params( session_id: String, @@ -152,11 +165,14 @@ module WorkOS email_verified: T.nilable(T::Boolean), metadata: T.nilable(T::Hash[String, String]), external_id: T.nilable(String), + ip_address: T.nilable(String), + user_agent: T.nilable(String), + signals_id: T.nilable(String), password: T.nilable(T.any(WorkOS::UserManagement::PasswordPlaintext, WorkOS::UserManagement::PasswordHashed)), request_options: T::Hash[Symbol, T.untyped] - ).returns(WorkOS::User) + ).returns(WorkOS::UserCreateResponse) end - def create_user(email:, first_name:, last_name:, name:, email_verified:, metadata:, external_id:, password:, request_options:); end + def create_user(email:, first_name:, last_name:, name:, email_verified:, metadata:, external_id:, ip_address:, user_agent:, signals_id:, password:, request_options:); end sig do params( @@ -340,10 +356,14 @@ module WorkOS params( email: String, invitation_token: T.nilable(String), + ip_address: T.nilable(String), + user_agent: T.nilable(String), + radar_auth_attempt_id: T.nilable(String), + signals_id: T.nilable(String), request_options: T::Hash[Symbol, T.untyped] - ).returns(WorkOS::MagicAuth) + ).returns(WorkOS::MagicAuthSendMagicAuthCodeAndReturnResponse) end - def create_magic_auth(email:, invitation_token:, request_options:); end + def create_magic_auth(email:, invitation_token:, ip_address:, user_agent:, radar_auth_attempt_id:, signals_id:, request_options:); end sig do params( diff --git a/test/workos/test_user_management.rb b/test/workos/test_user_management.rb index 10902f50..f5cef36b 100644 --- a/test/workos/test_user_management.rb +++ b/test/workos/test_user_management.rb @@ -152,6 +152,13 @@ def test_create_device_returns_expected_result refute_nil result end + def test_create_radar_challenge_returns_expected_result + stub_request(:post, %r{\Ahttps://api\.workos\.com/user_management/radar_challenges(\?|\z)}) + .to_return(body: "{}", status: 200) + result = @client.user_management.create_radar_challenge(user_id: "stub", pending_authentication_token: "stub", phone_number: "stub") + refute_nil result + end + def test_revoke_session_returns_expected_result stub_request(:post, %r{\Ahttps://api\.workos\.com/user_management/sessions/revoke(\?|\z)}) .to_return(body: "{}", status: 200) @@ -427,6 +434,7 @@ def test_create_user_api_key_returns_expected_result {name: :get_jwks, verb: :get, url: %r{\Ahttps://api\.workos\.com/sso/jwks/stub(\?|\z)}, args: {client_id: "stub"}}, {name: :create_authenticate, verb: :post, url: %r{\Ahttps://api\.workos\.com/user_management/authenticate(\?|\z)}, args: {client_id: "stub", grant_type: "authorization_code", code: "stub"}}, {name: :create_device, verb: :post, url: %r{\Ahttps://api\.workos\.com/user_management/authorize/device(\?|\z)}, args: {client_id: "stub"}}, + {name: :create_radar_challenge, verb: :post, url: %r{\Ahttps://api\.workos\.com/user_management/radar_challenges(\?|\z)}, args: {user_id: "stub", pending_authentication_token: "stub", phone_number: "stub"}}, {name: :revoke_session, verb: :post, url: %r{\Ahttps://api\.workos\.com/user_management/sessions/revoke(\?|\z)}, args: {session_id: "stub"}}, {name: :list_cors_origins, verb: :get, url: %r{\Ahttps://api\.workos\.com/user_management/cors_origins(\?|\z)}}, {name: :create_cors_origin, verb: :post, url: %r{\Ahttps://api\.workos\.com/user_management/cors_origins(\?|\z)}, args: {origin: "stub"}}, diff --git a/test/workos/test_user_management_model_round_trip.rb b/test/workos/test_user_management_model_round_trip.rb index 5aea7f69..fdcb6a21 100644 --- a/test/workos/test_user_management_model_round_trip.rb +++ b/test/workos/test_user_management_model_round_trip.rb @@ -27,6 +27,23 @@ def test_update_jwt_template_round_trip fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" } end + def test_send_radar_sms_challenge_round_trip + fixture = { + "user_id" => "stub", + "pending_authentication_token" => "stub", + "phone_number" => "stub", + "ip_address" => "stub", + "user_agent" => "stub" + } + model = WorkOS::SendRadarSmsChallenge.new(fixture.to_json) + json = model.to_h + assert_kind_of Hash, json + assert_equal fixture["user_id"], json[:user_id] + assert_equal fixture["pending_authentication_token"], json[:pending_authentication_token] + assert_equal fixture["phone_number"], json[:phone_number] + fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" } + end + def test_create_redirect_uri_round_trip fixture = { "uri" => "stub" @@ -41,7 +58,11 @@ def test_create_redirect_uri_round_trip def test_create_magic_code_and_return_round_trip fixture = { "email" => "stub", - "invitation_token" => "stub" + "invitation_token" => "stub", + "ip_address" => "stub", + "user_agent" => "stub", + "radar_auth_attempt_id" => "stub", + "signals_id" => "stub" } model = WorkOS::CreateMagicCodeAndReturn.new(fixture.to_json) json = model.to_h @@ -100,6 +121,9 @@ def test_create_user_round_trip "email_verified" => nil, "metadata" => nil, "external_id" => nil, + "ip_address" => nil, + "user_agent" => nil, + "signals_id" => "stub", "password" => nil, "password_hash" => "stub", "password_hash_type" => "stub" @@ -250,6 +274,19 @@ def test_cors_origin_response_round_trip fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" } end + def test_send_radar_sms_challenge_response_round_trip + fixture = { + "verification_id" => "stub", + "phone_number" => "stub" + } + model = WorkOS::SendRadarSmsChallengeResponse.new(fixture.to_json) + json = model.to_h + assert_kind_of Hash, json + assert_equal fixture["verification_id"], json[:verification_id] + assert_equal fixture["phone_number"], json[:phone_number] + fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" } + end + def test_redirect_uri_round_trip fixture = { "object" => "redirect_uri", @@ -634,7 +671,8 @@ def test_authorization_code_session_authenticate_request_round_trip "invitation_token" => "stub", "ip_address" => "stub", "device_id" => "stub", - "user_agent" => "stub" + "user_agent" => "stub", + "signals_id" => "stub" } model = WorkOS::AuthorizationCodeSessionAuthenticateRequest.new(fixture.to_json) json = model.to_h @@ -654,7 +692,9 @@ def test_password_session_authenticate_request_round_trip "invitation_token" => "stub", "ip_address" => "stub", "device_id" => "stub", - "user_agent" => "stub" + "user_agent" => "stub", + "signals_id" => "stub", + "radar_auth_attempt_id" => "stub" } model = WorkOS::PasswordSessionAuthenticateRequest.new(fixture.to_json) json = model.to_h @@ -695,7 +735,8 @@ def test_magic_auth_code_session_authenticate_request_round_trip "invitation_token" => "stub", "ip_address" => "stub", "device_id" => "stub", - "user_agent" => "stub" + "user_agent" => "stub", + "radar_auth_attempt_id" => "stub" } model = WorkOS::MagicAuthCodeSessionAuthenticateRequest.new(fixture.to_json) json = model.to_h @@ -772,6 +813,54 @@ def test_organization_selection_session_authenticate_request_round_trip fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" } end + def test_radar_email_challenge_code_session_authenticate_request_round_trip + fixture = { + "client_id" => "stub", + "client_secret" => "stub", + "grant_type" => "urn:workos:oauth:grant-type:radar-email-challenge:code", + "code" => "stub", + "radar_challenge_id" => "stub", + "pending_authentication_token" => "stub", + "ip_address" => "stub", + "device_id" => "stub", + "user_agent" => "stub" + } + model = WorkOS::RadarEmailChallengeCodeSessionAuthenticateRequest.new(fixture.to_json) + json = model.to_h + assert_kind_of Hash, json + assert_equal fixture["client_id"], json[:client_id] + assert_equal fixture["client_secret"], json[:client_secret] + assert_equal fixture["code"], json[:code] + assert_equal fixture["radar_challenge_id"], json[:radar_challenge_id] + assert_equal fixture["pending_authentication_token"], json[:pending_authentication_token] + 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_challenge_code_session_authenticate_request_round_trip + fixture = { + "client_id" => "stub", + "client_secret" => "stub", + "grant_type" => "urn:workos:oauth:grant-type:radar-sms-challenge:code", + "code" => "stub", + "verification_id" => "stub", + "phone_number" => "stub", + "pending_authentication_token" => "stub", + "ip_address" => "stub", + "device_id" => "stub", + "user_agent" => "stub" + } + model = WorkOS::RadarSmsChallengeCodeSessionAuthenticateRequest.new(fixture.to_json) + json = model.to_h + assert_kind_of Hash, json + assert_equal fixture["client_id"], json[:client_id] + assert_equal fixture["client_secret"], json[:client_secret] + assert_equal fixture["code"], json[:code] + assert_equal fixture["verification_id"], json[:verification_id] + assert_equal fixture["phone_number"], json[:phone_number] + assert_equal fixture["pending_authentication_token"], json[:pending_authentication_token] + fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" } + end + def test_device_code_session_authenticate_request_round_trip fixture = { "client_id" => "stub", @@ -837,6 +926,26 @@ def test_invitation_round_trip fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" } end + def test_magic_auth_send_magic_auth_code_and_return_response_round_trip + fixture = { + "radar_auth_attempt_id" => "stub" + } + model = WorkOS::MagicAuthSendMagicAuthCodeAndReturnResponse.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_user_create_response_round_trip + fixture = { + "radar_auth_attempt_id" => "stub" + } + model = WorkOS::UserCreateResponse.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_email_change_confirmation_round_trip fixture = { "object" => "email_change_confirmation", From 7c982ed3f868cbb173c43c2fc1e36356ce1f96b4 Mon Sep 17 00:00:00 2001 From: "workos-sdk-automation[bot]" <255426317+workos-sdk-automation[bot]@users.noreply.github.com> Date: Thu, 2 Jul 2026 14:11:26 +0000 Subject: [PATCH 2/4] fix(user_management): Update user management API surface --- ..._auth_code_session_authenticate_request.rb | 7 +- ...end_magic_auth_code_and_return_response.rb | 18 +++++ ...lenge_code_session_authenticate_request.rb | 43 ++++++++++ ...lenge_code_session_authenticate_request.rb | 46 +++++++++++ ...auth_code_session_authenticate_request.rbi | 6 ++ ...enge_code_session_authenticate_request.rbi | 72 +++++++++++++++++ ...enge_code_session_authenticate_request.rbi | 78 +++++++++++++++++++ 7 files changed, 268 insertions(+), 2 deletions(-) create mode 100644 lib/workos/user_management/magic_auth_send_magic_auth_code_and_return_response.rb create mode 100644 lib/workos/user_management/radar_email_challenge_code_session_authenticate_request.rb create mode 100644 lib/workos/user_management/radar_sms_challenge_code_session_authenticate_request.rb create mode 100644 rbi/workos/radar_email_challenge_code_session_authenticate_request.rbi create mode 100644 rbi/workos/radar_sms_challenge_code_session_authenticate_request.rbi diff --git a/lib/workos/user_management/magic_auth_code_session_authenticate_request.rb b/lib/workos/user_management/magic_auth_code_session_authenticate_request.rb index aad2df18..91917919 100644 --- a/lib/workos/user_management/magic_auth_code_session_authenticate_request.rb +++ b/lib/workos/user_management/magic_auth_code_session_authenticate_request.rb @@ -13,7 +13,8 @@ class MagicAuthCodeSessionAuthenticateRequest < WorkOS::Types::BaseModel invitation_token: :invitation_token, ip_address: :ip_address, device_id: :device_id, - user_agent: :user_agent + user_agent: :user_agent, + radar_auth_attempt_id: :radar_auth_attempt_id }.freeze attr_accessor \ @@ -25,7 +26,8 @@ class MagicAuthCodeSessionAuthenticateRequest < WorkOS::Types::BaseModel :invitation_token, :ip_address, :device_id, - :user_agent + :user_agent, + :radar_auth_attempt_id def initialize(json) hash = self.class.normalize(json) @@ -38,6 +40,7 @@ def initialize(json) @ip_address = hash[:ip_address] @device_id = hash[:device_id] @user_agent = hash[:user_agent] + @radar_auth_attempt_id = hash[:radar_auth_attempt_id] end end end diff --git a/lib/workos/user_management/magic_auth_send_magic_auth_code_and_return_response.rb b/lib/workos/user_management/magic_auth_send_magic_auth_code_and_return_response.rb new file mode 100644 index 00000000..c721a1e6 --- /dev/null +++ b/lib/workos/user_management/magic_auth_send_magic_auth_code_and_return_response.rb @@ -0,0 +1,18 @@ +# frozen_string_literal: true + +# This file is auto-generated by oagen. Do not edit. + +module WorkOS + class MagicAuthSendMagicAuthCodeAndReturnResponse < WorkOS::Types::BaseModel + HASH_ATTRS = { + radar_auth_attempt_id: :radar_auth_attempt_id + }.freeze + + attr_accessor :radar_auth_attempt_id + + def initialize(json) + hash = self.class.normalize(json) + @radar_auth_attempt_id = hash[:radar_auth_attempt_id] + end + end +end diff --git a/lib/workos/user_management/radar_email_challenge_code_session_authenticate_request.rb b/lib/workos/user_management/radar_email_challenge_code_session_authenticate_request.rb new file mode 100644 index 00000000..07d70de3 --- /dev/null +++ b/lib/workos/user_management/radar_email_challenge_code_session_authenticate_request.rb @@ -0,0 +1,43 @@ +# frozen_string_literal: true + +# This file is auto-generated by oagen. Do not edit. + +module WorkOS + class RadarEmailChallengeCodeSessionAuthenticateRequest < WorkOS::Types::BaseModel + HASH_ATTRS = { + client_id: :client_id, + client_secret: :client_secret, + grant_type: :grant_type, + code: :code, + radar_challenge_id: :radar_challenge_id, + pending_authentication_token: :pending_authentication_token, + ip_address: :ip_address, + device_id: :device_id, + user_agent: :user_agent + }.freeze + + attr_accessor \ + :client_id, + :client_secret, + :grant_type, + :code, + :radar_challenge_id, + :pending_authentication_token, + :ip_address, + :device_id, + :user_agent + + def initialize(json) + hash = self.class.normalize(json) + @client_id = hash[:client_id] + @client_secret = hash[:client_secret] + @grant_type = hash[:grant_type] + @code = hash[:code] + @radar_challenge_id = hash[:radar_challenge_id] + @pending_authentication_token = hash[:pending_authentication_token] + @ip_address = hash[:ip_address] + @device_id = hash[:device_id] + @user_agent = hash[:user_agent] + end + end +end diff --git a/lib/workos/user_management/radar_sms_challenge_code_session_authenticate_request.rb b/lib/workos/user_management/radar_sms_challenge_code_session_authenticate_request.rb new file mode 100644 index 00000000..de17c705 --- /dev/null +++ b/lib/workos/user_management/radar_sms_challenge_code_session_authenticate_request.rb @@ -0,0 +1,46 @@ +# frozen_string_literal: true + +# This file is auto-generated by oagen. Do not edit. + +module WorkOS + class RadarSmsChallengeCodeSessionAuthenticateRequest < WorkOS::Types::BaseModel + HASH_ATTRS = { + client_id: :client_id, + client_secret: :client_secret, + grant_type: :grant_type, + code: :code, + verification_id: :verification_id, + phone_number: :phone_number, + pending_authentication_token: :pending_authentication_token, + ip_address: :ip_address, + device_id: :device_id, + user_agent: :user_agent + }.freeze + + attr_accessor \ + :client_id, + :client_secret, + :grant_type, + :code, + :verification_id, + :phone_number, + :pending_authentication_token, + :ip_address, + :device_id, + :user_agent + + def initialize(json) + hash = self.class.normalize(json) + @client_id = hash[:client_id] + @client_secret = hash[:client_secret] + @grant_type = hash[:grant_type] + @code = hash[:code] + @verification_id = hash[:verification_id] + @phone_number = hash[:phone_number] + @pending_authentication_token = hash[:pending_authentication_token] + @ip_address = hash[:ip_address] + @device_id = hash[:device_id] + @user_agent = hash[:user_agent] + end + end +end diff --git a/rbi/workos/magic_auth_code_session_authenticate_request.rbi b/rbi/workos/magic_auth_code_session_authenticate_request.rbi index 36442669..8d818ad0 100644 --- a/rbi/workos/magic_auth_code_session_authenticate_request.rbi +++ b/rbi/workos/magic_auth_code_session_authenticate_request.rbi @@ -63,6 +63,12 @@ module WorkOS sig { params(value: T.nilable(String)).returns(T.nilable(String)) } def user_agent=(value); end + sig { returns(T.nilable(String)) } + def radar_auth_attempt_id; end + + sig { params(value: T.nilable(String)).returns(T.nilable(String)) } + def radar_auth_attempt_id=(value); end + sig { returns(T::Hash[Symbol, T.untyped]) } def to_h; end diff --git a/rbi/workos/radar_email_challenge_code_session_authenticate_request.rbi b/rbi/workos/radar_email_challenge_code_session_authenticate_request.rbi new file mode 100644 index 00000000..7bc362fa --- /dev/null +++ b/rbi/workos/radar_email_challenge_code_session_authenticate_request.rbi @@ -0,0 +1,72 @@ +# frozen_string_literal: true + +# This file is auto-generated by oagen. Do not edit. + +# typed: strong + +module WorkOS + class RadarEmailChallengeCodeSessionAuthenticateRequest + sig { params(json: T.any(String, T::Hash[Symbol, T.untyped])).void } + def initialize(json); end + + sig { returns(String) } + def client_id; end + + sig { params(value: String).returns(String) } + def client_id=(value); end + + sig { returns(String) } + def client_secret; end + + sig { params(value: String).returns(String) } + def client_secret=(value); end + + sig { returns(String) } + def grant_type; end + + sig { params(value: String).returns(String) } + def grant_type=(value); end + + sig { returns(String) } + def code; end + + sig { params(value: String).returns(String) } + def code=(value); end + + sig { returns(String) } + def radar_challenge_id; end + + sig { params(value: String).returns(String) } + def radar_challenge_id=(value); end + + sig { returns(String) } + def pending_authentication_token; end + + sig { params(value: String).returns(String) } + def pending_authentication_token=(value); end + + sig { returns(T.nilable(String)) } + def ip_address; end + + sig { params(value: T.nilable(String)).returns(T.nilable(String)) } + def ip_address=(value); end + + sig { returns(T.nilable(String)) } + def device_id; end + + sig { params(value: T.nilable(String)).returns(T.nilable(String)) } + def device_id=(value); end + + sig { returns(T.nilable(String)) } + def user_agent; end + + sig { params(value: T.nilable(String)).returns(T.nilable(String)) } + def user_agent=(value); end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h; end + + sig { params(args: T.untyped).returns(String) } + def to_json(*args); end + end +end diff --git a/rbi/workos/radar_sms_challenge_code_session_authenticate_request.rbi b/rbi/workos/radar_sms_challenge_code_session_authenticate_request.rbi new file mode 100644 index 00000000..aa2dc86a --- /dev/null +++ b/rbi/workos/radar_sms_challenge_code_session_authenticate_request.rbi @@ -0,0 +1,78 @@ +# frozen_string_literal: true + +# This file is auto-generated by oagen. Do not edit. + +# typed: strong + +module WorkOS + class RadarSmsChallengeCodeSessionAuthenticateRequest + sig { params(json: T.any(String, T::Hash[Symbol, T.untyped])).void } + def initialize(json); end + + sig { returns(String) } + def client_id; end + + sig { params(value: String).returns(String) } + def client_id=(value); end + + sig { returns(String) } + def client_secret; end + + sig { params(value: String).returns(String) } + def client_secret=(value); end + + sig { returns(String) } + def grant_type; end + + sig { params(value: String).returns(String) } + def grant_type=(value); end + + sig { returns(String) } + def code; end + + sig { params(value: String).returns(String) } + def code=(value); end + + sig { returns(String) } + def verification_id; end + + sig { params(value: String).returns(String) } + def verification_id=(value); end + + sig { returns(String) } + def phone_number; end + + sig { params(value: String).returns(String) } + def phone_number=(value); end + + sig { returns(String) } + def pending_authentication_token; end + + sig { params(value: String).returns(String) } + def pending_authentication_token=(value); end + + sig { returns(T.nilable(String)) } + def ip_address; end + + sig { params(value: T.nilable(String)).returns(T.nilable(String)) } + def ip_address=(value); end + + sig { returns(T.nilable(String)) } + def device_id; end + + sig { params(value: T.nilable(String)).returns(T.nilable(String)) } + def device_id=(value); end + + sig { returns(T.nilable(String)) } + def user_agent; end + + sig { params(value: T.nilable(String)).returns(T.nilable(String)) } + def user_agent=(value); end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h; end + + sig { params(args: T.untyped).returns(String) } + def to_json(*args); end + end +end From 83ad9892aae72870149c01a4e20932c333318a84 Mon Sep 17 00:00:00 2001 From: "workos-sdk-automation[bot]" <255426317+workos-sdk-automation[bot]@users.noreply.github.com> Date: Thu, 2 Jul 2026 14:11:26 +0000 Subject: [PATCH 3/4] chore(generated): regenerate shared files for Radar, UserManagement --- .last-synced-sha | 2 +- .oagen-manifest.json | 47 +++++++++- lib/workos/radar.rb | 7 +- .../radar/radar_standalone_assess_request.rb | 7 +- rbi/workos/radar.rbi | 3 +- .../radar_standalone_assess_request.rbi | 6 ++ test/workos/test_radar_model_round_trip.rb | 85 +++++++++++++++++++ 7 files changed, 150 insertions(+), 7 deletions(-) create mode 100644 test/workos/test_radar_model_round_trip.rb diff --git a/.last-synced-sha b/.last-synced-sha index cdc071b3..639e2e87 100644 --- a/.last-synced-sha +++ b/.last-synced-sha @@ -1 +1 @@ -dc04d30b352063b5c97e45de03be5c83629f5412 +4b4e0618779460dbebc1cf5e0f02197c21796d1f diff --git a/.oagen-manifest.json b/.oagen-manifest.json index be22b1a6..2ab94a13 100644 --- a/.oagen-manifest.json +++ b/.oagen-manifest.json @@ -1,7 +1,7 @@ { "version": 2, "language": "ruby", - "generatedAt": "2026-07-01T18:19:13.490Z", + "generatedAt": "2026-07-02T14:11:06.238Z", "files": [ "lib/workos.rb", "lib/workos/admin_portal.rb", @@ -545,6 +545,7 @@ "lib/workos/user_management/magic_auth_code_session_authenticate_request.rb", "lib/workos/user_management/magic_auth_created.rb", "lib/workos/user_management/magic_auth_created_data.rb", + "lib/workos/user_management/magic_auth_send_magic_auth_code_and_return_response.rb", "lib/workos/user_management/mfa_totp_session_authenticate_request.rb", "lib/workos/user_management/organization_selection_session_authenticate_request.rb", "lib/workos/user_management/password_reset.rb", @@ -553,12 +554,16 @@ "lib/workos/user_management/password_reset_succeeded.rb", "lib/workos/user_management/password_reset_succeeded_data.rb", "lib/workos/user_management/password_session_authenticate_request.rb", + "lib/workos/user_management/radar_email_challenge_code_session_authenticate_request.rb", + "lib/workos/user_management/radar_sms_challenge_code_session_authenticate_request.rb", "lib/workos/user_management/redirect_uri.rb", "lib/workos/user_management/refresh_token_session_authenticate_request.rb", "lib/workos/user_management/resend_user_invite_options.rb", "lib/workos/user_management/reset_password_response.rb", "lib/workos/user_management/revoke_session.rb", "lib/workos/user_management/send_email_change.rb", + "lib/workos/user_management/send_radar_sms_challenge.rb", + "lib/workos/user_management/send_radar_sms_challenge_response.rb", "lib/workos/user_management/send_verification_email_response.rb", "lib/workos/user_management/session_created.rb", "lib/workos/user_management/session_created_data.rb", @@ -577,6 +582,7 @@ "lib/workos/user_management/user_api_key_updated_data_owner.rb", "lib/workos/user_management/user_api_key_with_value.rb", "lib/workos/user_management/user_api_key_with_value_owner.rb", + "lib/workos/user_management/user_create_response.rb", "lib/workos/user_management/user_created.rb", "lib/workos/user_management/user_deleted.rb", "lib/workos/user_management/user_identities_get_item.rb", @@ -933,6 +939,7 @@ "rbi/workos/magic_auth_code_session_authenticate_request.rbi", "rbi/workos/magic_auth_created.rbi", "rbi/workos/magic_auth_created_data.rbi", + "rbi/workos/magic_auth_send_magic_auth_code_and_return_response.rbi", "rbi/workos/mfa_totp_session_authenticate_request.rbi", "rbi/workos/multi_factor_auth.rbi", "rbi/workos/new_connect_application_secret.rbi", @@ -1008,7 +1015,9 @@ "rbi/workos/portal_link_response.rbi", "rbi/workos/profile.rbi", "rbi/workos/radar.rbi", + "rbi/workos/radar_email_challenge_code_session_authenticate_request.rbi", "rbi/workos/radar_list_entry_already_present_response.rbi", + "rbi/workos/radar_sms_challenge_code_session_authenticate_request.rbi", "rbi/workos/radar_standalone_assess_request.rbi", "rbi/workos/radar_standalone_delete_radar_list_entry_request.rbi", "rbi/workos/radar_standalone_response.rbi", @@ -1033,6 +1042,8 @@ "rbi/workos/role_updated.rbi", "rbi/workos/role_updated_data.rbi", "rbi/workos/send_email_change.rbi", + "rbi/workos/send_radar_sms_challenge.rbi", + "rbi/workos/send_radar_sms_challenge_response.rbi", "rbi/workos/send_verification_email_response.rbi", "rbi/workos/session_created.rbi", "rbi/workos/session_created_data.rbi", @@ -1075,6 +1086,7 @@ "rbi/workos/user_authentication_factor_enroll_response.rbi", "rbi/workos/user_consent_option.rbi", "rbi/workos/user_consent_option_choice.rbi", + "rbi/workos/user_create_response.rbi", "rbi/workos/user_created.rbi", "rbi/workos/user_deleted.rbi", "rbi/workos/user_identities_get_item.rbi", @@ -1150,6 +1162,7 @@ "test/workos/test_pipes.rb", "test/workos/test_pipes_provider.rb", "test/workos/test_radar.rb", + "test/workos/test_radar_model_round_trip.rb", "test/workos/test_shared_model_round_trip.rb", "test/workos/test_sso.rb", "test/workos/test_user_management.rb", @@ -1987,6 +2000,38 @@ "GET /user_management/redirect_uris": { "sdkMethod": "list_redirect_uris", "service": "user_management" + }, + "GET /data-integrations": { + "sdkMethod": "list_data_integrations", + "service": "pipes" + }, + "POST /data-integrations": { + "sdkMethod": "create_data_integration", + "service": "pipes" + }, + "GET /data-integrations/{slug}": { + "sdkMethod": "get_data_integration", + "service": "pipes" + }, + "PUT /data-integrations/{slug}": { + "sdkMethod": "update_data_integration", + "service": "pipes" + }, + "DELETE /data-integrations/{slug}": { + "sdkMethod": "delete_data_integration", + "service": "pipes" + }, + "POST /user_management/radar_challenges": { + "sdkMethod": "create_radar_challenge", + "service": "user_management" + }, + "POST /user_management/users/{user_id}/connected_accounts/{slug}": { + "sdkMethod": "create_user_connected_account", + "service": "pipes" + }, + "PUT /user_management/users/{user_id}/connected_accounts/{slug}": { + "sdkMethod": "update_user_connected_account", + "service": "pipes" } } } diff --git a/lib/workos/radar.rb b/lib/workos/radar.rb index 837815dc..a269905d 100644 --- a/lib/workos/radar.rb +++ b/lib/workos/radar.rb @@ -16,6 +16,7 @@ def initialize(client) # @param email [String] The email address of the user making the request. # @param auth_method [WorkOS::Types::RadarStandaloneAssessRequestAuthMethod] The authentication method being used. # @param action [WorkOS::Types::RadarStandaloneAssessRequestAction] The action being performed. + # @param signals_id [String, nil] An optional Radar signals ID for the request. # @param request_options [Hash] (see WorkOS::Types::RequestOptions) # @return [WorkOS::RadarStandaloneResponse] def create_attempt( @@ -24,6 +25,7 @@ def create_attempt( email:, auth_method:, action:, + signals_id: nil, request_options: {} ) body = { @@ -31,8 +33,9 @@ def create_attempt( "user_agent" => user_agent, "email" => email, "auth_method" => auth_method, - "action" => action - } + "action" => action, + "signals_id" => signals_id + }.compact response = @client.request( method: :post, path: "/radar/attempts", diff --git a/lib/workos/radar/radar_standalone_assess_request.rb b/lib/workos/radar/radar_standalone_assess_request.rb index ce7a4b9d..3992c237 100644 --- a/lib/workos/radar/radar_standalone_assess_request.rb +++ b/lib/workos/radar/radar_standalone_assess_request.rb @@ -9,7 +9,8 @@ class RadarStandaloneAssessRequest < WorkOS::Types::BaseModel user_agent: :user_agent, email: :email, auth_method: :auth_method, - action: :action + action: :action, + signals_id: :signals_id }.freeze attr_accessor \ @@ -17,7 +18,8 @@ class RadarStandaloneAssessRequest < WorkOS::Types::BaseModel :user_agent, :email, :auth_method, - :action + :action, + :signals_id def initialize(json) hash = self.class.normalize(json) @@ -26,6 +28,7 @@ def initialize(json) @email = hash[:email] @auth_method = hash[:auth_method] @action = hash[:action] + @signals_id = hash[:signals_id] end end end diff --git a/rbi/workos/radar.rbi b/rbi/workos/radar.rbi index 5995a928..704e565b 100644 --- a/rbi/workos/radar.rbi +++ b/rbi/workos/radar.rbi @@ -16,10 +16,11 @@ module WorkOS email: String, auth_method: String, action: String, + signals_id: T.nilable(String), request_options: T::Hash[Symbol, T.untyped] ).returns(WorkOS::RadarStandaloneResponse) end - def create_attempt(ip_address:, user_agent:, email:, auth_method:, action:, request_options:); end + def create_attempt(ip_address:, user_agent:, email:, auth_method:, action:, signals_id:, request_options:); end sig do params( diff --git a/rbi/workos/radar_standalone_assess_request.rbi b/rbi/workos/radar_standalone_assess_request.rbi index c5c474ca..16d31b05 100644 --- a/rbi/workos/radar_standalone_assess_request.rbi +++ b/rbi/workos/radar_standalone_assess_request.rbi @@ -39,6 +39,12 @@ module WorkOS sig { params(value: String).returns(String) } def action=(value); end + sig { returns(T.nilable(String)) } + def signals_id; end + + sig { params(value: T.nilable(String)).returns(T.nilable(String)) } + def signals_id=(value); end + sig { returns(T::Hash[Symbol, T.untyped]) } def to_h; end diff --git a/test/workos/test_radar_model_round_trip.rb b/test/workos/test_radar_model_round_trip.rb new file mode 100644 index 00000000..02831fab --- /dev/null +++ b/test/workos/test_radar_model_round_trip.rb @@ -0,0 +1,85 @@ +# frozen_string_literal: true + +# This file is auto-generated by oagen. Do not edit. + +require "test_helper" + +class RadarModelRoundTripTest < Minitest::Test + def test_radar_standalone_response_round_trip + fixture = { + "verdict" => "stub", + "reason" => "stub", + "attempt_id" => "stub", + "control" => "stub", + "blocklist_type" => "stub" + } + model = WorkOS::RadarStandaloneResponse.new(fixture.to_json) + json = model.to_h + assert_kind_of Hash, json + assert_equal fixture["reason"], json[:reason] + assert_equal fixture["attempt_id"], json[:attempt_id] + fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" } + end + + def test_radar_list_entry_already_present_response_round_trip + fixture = { + "message" => "stub" + } + model = WorkOS::RadarListEntryAlreadyPresentResponse.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_standalone_assess_request_round_trip + fixture = { + "ip_address" => "stub", + "user_agent" => "stub", + "email" => "stub", + "auth_method" => "stub", + "action" => "stub", + "signals_id" => "stub" + } + model = WorkOS::RadarStandaloneAssessRequest.new(fixture.to_json) + json = model.to_h + assert_kind_of Hash, json + assert_equal fixture["ip_address"], json[:ip_address] + assert_equal fixture["user_agent"], json[:user_agent] + 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 + + def test_radar_standalone_update_radar_attempt_request_round_trip + fixture = { + "challenge_status" => "success", + "attempt_status" => "success" + } + model = WorkOS::RadarStandaloneUpdateRadarAttemptRequest.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_radar_standalone_update_radar_list_request_round_trip + fixture = { + "entry" => "stub" + } + model = WorkOS::RadarStandaloneUpdateRadarListRequest.new(fixture.to_json) + json = model.to_h + assert_kind_of Hash, json + assert_equal fixture["entry"], json[:entry] + fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" } + end + + def test_radar_standalone_delete_radar_list_entry_request_round_trip + fixture = { + "entry" => "stub" + } + model = WorkOS::RadarStandaloneDeleteRadarListEntryRequest.new(fixture.to_json) + json = model.to_h + assert_kind_of Hash, json + assert_equal fixture["entry"], json[:entry] + fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" } + end +end From f291704f13b1a4f8dcb24acc122f1454663c80b7 Mon Sep 17 00:00:00 2001 From: "workos-sdk-automation[bot]" <255426317+workos-sdk-automation[bot]@users.noreply.github.com> Date: Thu, 2 Jul 2026 14:11:33 +0000 Subject: [PATCH 4/4] chore(generated): add release notes fragment --- ...350eb0b1521b954c25625b4858b2fd14a506cd2.md | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 .changelog-pending/2026-07-02T14-11-33-e350eb0b1521b954c25625b4858b2fd14a506cd2.md diff --git a/.changelog-pending/2026-07-02T14-11-33-e350eb0b1521b954c25625b4858b2fd14a506cd2.md b/.changelog-pending/2026-07-02T14-11-33-e350eb0b1521b954c25625b4858b2fd14a506cd2.md new file mode 100644 index 00000000..7c6fc444 --- /dev/null +++ b/.changelog-pending/2026-07-02T14-11-33-e350eb0b1521b954c25625b4858b2fd14a506cd2.md @@ -0,0 +1,30 @@ +* [#511](https://github.com/workos/workos-ruby/pull/511) feat(generated): regenerate from spec (2 changes) + + **Features** + * **[radar](https://workos.com/docs/reference/radar)**: + * Added `signals_id` to `RadarStandaloneAssessRequest` + * **[user_management](https://workos.com/docs/reference/authkit/user)**: + * Added model `SendRadarSmsChallenge` + * Added model `SendRadarSmsChallengeResponse` + * Added model `UrnWorkosOAuthGrantTypeRadarEmailChallengeCodeSessionAuthenticateRequest` + * Added model `UrnWorkosOAuthGrantTypeRadarSmsChallengeCodeSessionAuthenticateRequest` + * Added model `MagicAuthSendMagicAuthCodeAndReturnResponse` + * Added model `UserCreateResponse` + * Added `ip_address` to `CreateMagicCodeAndReturn` + * Added `user_agent` to `CreateMagicCodeAndReturn` + * Added `radar_auth_attempt_id` to `CreateMagicCodeAndReturn` + * Added `signals_id` to `CreateMagicCodeAndReturn` + * Added `ip_address` to `CreateUser` + * Added `user_agent` to `CreateUser` + * Added `signals_id` to `CreateUser` + * Added `signals_id` to `AuthorizationCodeSessionAuthenticateRequest` + * Added `signals_id` to `PasswordSessionAuthenticateRequest` + * Added `radar_auth_attempt_id` to `PasswordSessionAuthenticateRequest` + * Added `radar_auth_attempt_id` to `UrnWorkosOAuthGrantTypeMagicAuthCodeSessionAuthenticateRequest` + * Added endpoint `POST /user_management/radar_challenges` + + **Fixes** + * **[user_management](https://workos.com/docs/reference/authkit/user)**: + * Changed request body for `UserManagementAuthentication.authenticate` + * Changed response of `UserManagementUsers.create` from `User` to `UserCreateResponse` + * Changed response of `UserManagementMagicAuth.sendMagicAuthCodeAndReturn` from `MagicAuth` to `MagicAuthSendMagicAuthCodeAndReturnResponse`