workos 10.2.1 → 10.3.0

data/test/workos/test_sso.rb

@@ -18,6 +18,85 @@ class SSOTest < Minitest::Test
     assert_kind_of WorkOS::Types::ListStruct, result
   end
 
+  def test_create_connection_returns_expected_result
+    stub_request(:post, %r{\Ahttps://api\.workos\.com/connections(\?|\z)})
+      .with(body: hash_including("organization_id" => "stub", "saml_options" => {}))
+      .to_return(body: "{}", status: 200)
+    result = @client.sso.create_connection(organization_id: "stub", protocol_options: WorkOS::SSO::CreateProtocolOptionsSAML.new(saml_options: {}))
+    refute_nil result
+  end
+
+  def test_create_connection_with_protocol_options_oidc_returns_expected_result
+    stub_request(:post, %r{\Ahttps://api\.workos\.com/connections(\?|\z)})
+      .with(body: hash_including("organization_id" => "stub", "oidc_options" => {}))
+      .to_return(body: "{}", status: 200)
+    result = @client.sso.create_connection(organization_id: "stub", protocol_options: WorkOS::SSO::CreateProtocolOptionsOIDC.new(oidc_options: {}))
+    refute_nil result
+  end
+
+  def test_list_connection_saml_idp_signing_certs_returns_expected_result
+    stub_request(:get, %r{\Ahttps://api\.workos\.com/connections/stub/saml_idp_signing_certs(\?|\z)})
+      .to_return(body: "{}", status: 200)
+    result = @client.sso.list_connection_saml_idp_signing_certs(connection_id: "stub")
+    refute_nil result
+  end
+
+  def test_create_connection_saml_idp_signing_cert_returns_expected_result
+    stub_request(:post, %r{\Ahttps://api\.workos\.com/connections/stub/saml_idp_signing_certs(\?|\z)})
+      .to_return(body: "{}", status: 200)
+    result = @client.sso.create_connection_saml_idp_signing_cert(connection_id: "stub", value: "stub")
+    refute_nil result
+  end
+
+  def test_delete_connection_saml_idp_signing_cert_returns_expected_result
+    stub_request(:delete, %r{\Ahttps://api\.workos\.com/connections/stub/saml_idp_signing_certs/stub(\?|\z)})
+      .to_return(body: "{}", status: 200)
+    result = @client.sso.delete_connection_saml_idp_signing_cert(connection_id: "stub", certificate_id: "stub")
+    assert_nil result
+  end
+
+  def test_list_connection_saml_sp_encryption_certs_returns_expected_result
+    stub_request(:get, %r{\Ahttps://api\.workos\.com/connections/stub/saml_sp_encryption_certs(\?|\z)})
+      .to_return(body: "{}", status: 200)
+    result = @client.sso.list_connection_saml_sp_encryption_certs(connection_id: "stub")
+    refute_nil result
+  end
+
+  def test_create_connection_saml_sp_encryption_cert_returns_expected_result
+    stub_request(:post, %r{\Ahttps://api\.workos\.com/connections/stub/saml_sp_encryption_certs(\?|\z)})
+      .to_return(body: "{}", status: 200)
+    result = @client.sso.create_connection_saml_sp_encryption_cert(connection_id: "stub")
+    refute_nil result
+  end
+
+  def test_delete_connection_saml_sp_encryption_cert_returns_expected_result
+    stub_request(:delete, %r{\Ahttps://api\.workos\.com/connections/stub/saml_sp_encryption_certs/stub(\?|\z)})
+      .to_return(body: "{}", status: 200)
+    result = @client.sso.delete_connection_saml_sp_encryption_cert(connection_id: "stub", certificate_id: "stub")
+    assert_nil result
+  end
+
+  def test_list_connection_saml_sp_signing_cert_returns_expected_result
+    stub_request(:get, %r{\Ahttps://api\.workos\.com/connections/stub/saml_sp_signing_cert(\?|\z)})
+      .to_return(body: "{}", status: 200)
+    result = @client.sso.list_connection_saml_sp_signing_cert(connection_id: "stub")
+    refute_nil result
+  end
+
+  def test_create_connection_saml_sp_signing_cert_returns_expected_result
+    stub_request(:post, %r{\Ahttps://api\.workos\.com/connections/stub/saml_sp_signing_cert(\?|\z)})
+      .to_return(body: "{}", status: 200)
+    result = @client.sso.create_connection_saml_sp_signing_cert(connection_id: "stub")
+    refute_nil result
+  end
+
+  def test_delete_connection_saml_sp_signing_cert_returns_expected_result
+    stub_request(:delete, %r{\Ahttps://api\.workos\.com/connections/stub/saml_sp_signing_cert/stub(\?|\z)})
+      .to_return(body: "{}", status: 200)
+    result = @client.sso.delete_connection_saml_sp_signing_cert(connection_id: "stub", certificate_id: "stub")
+    assert_nil result
+  end
+
   def test_get_connection_returns_expected_result
     stub_request(:get, %r{\Ahttps://api\.workos\.com/connections/stub(\?|\z)})
       .to_return(body: "{}", status: 200)
@@ -25,6 +104,22 @@ class SSOTest < Minitest::Test
     refute_nil result
   end
 
+  def test_update_connection_returns_expected_result
+    stub_request(:patch, %r{\Ahttps://api\.workos\.com/connections/stub(\?|\z)})
+      .with(body: hash_including("saml_options" => {}))
+      .to_return(body: "{}", status: 200)
+    result = @client.sso.update_connection(id: "stub", protocol_options: WorkOS::SSO::PatchProtocolOptionsSAML.new(saml_options: {}))
+    refute_nil result
+  end
+
+  def test_update_connection_with_protocol_options_oidc_returns_expected_result
+    stub_request(:patch, %r{\Ahttps://api\.workos\.com/connections/stub(\?|\z)})
+      .with(body: hash_including("oidc_options" => {}))
+      .to_return(body: "{}", status: 200)
+    result = @client.sso.update_connection(id: "stub", protocol_options: WorkOS::SSO::PatchProtocolOptionsOIDC.new(oidc_options: {}))
+    refute_nil result
+  end
+
   def test_delete_connection_returns_expected_result
     stub_request(:delete, %r{\Ahttps://api\.workos\.com/connections/stub(\?|\z)})
       .to_return(body: "{}", status: 200)
@@ -49,18 +144,29 @@ class SSOTest < Minitest::Test
   def test_get_profile_and_token_returns_expected_result
     stub_request(:post, %r{\Ahttps://api\.workos\.com/sso/token(\?|\z)})
       .to_return(body: "{}", status: 200)
-    result = @client.sso.get_profile_and_token(code: "stub")
+    result = @client.sso.get_profile_and_token
     refute_nil result
   end
 
   # Parameterized authentication error tests (one per endpoint).
   [
     {name: :list_connections, verb: :get, url: %r{\Ahttps://api\.workos\.com/connections(\?|\z)}},
+    {name: :create_connection, verb: :post, url: %r{\Ahttps://api\.workos\.com/connections(\?|\z)}, args: {organization_id: "stub", protocol_options: WorkOS::SSO::CreateProtocolOptionsSAML.new(saml_options: {})}},
+    {name: :list_connection_saml_idp_signing_certs, verb: :get, url: %r{\Ahttps://api\.workos\.com/connections/stub/saml_idp_signing_certs(\?|\z)}, args: {connection_id: "stub"}},
+    {name: :create_connection_saml_idp_signing_cert, verb: :post, url: %r{\Ahttps://api\.workos\.com/connections/stub/saml_idp_signing_certs(\?|\z)}, args: {connection_id: "stub", value: "stub"}},
+    {name: :delete_connection_saml_idp_signing_cert, verb: :delete, url: %r{\Ahttps://api\.workos\.com/connections/stub/saml_idp_signing_certs/stub(\?|\z)}, args: {connection_id: "stub", certificate_id: "stub"}},
+    {name: :list_connection_saml_sp_encryption_certs, verb: :get, url: %r{\Ahttps://api\.workos\.com/connections/stub/saml_sp_encryption_certs(\?|\z)}, args: {connection_id: "stub"}},
+    {name: :create_connection_saml_sp_encryption_cert, verb: :post, url: %r{\Ahttps://api\.workos\.com/connections/stub/saml_sp_encryption_certs(\?|\z)}, args: {connection_id: "stub"}},
+    {name: :delete_connection_saml_sp_encryption_cert, verb: :delete, url: %r{\Ahttps://api\.workos\.com/connections/stub/saml_sp_encryption_certs/stub(\?|\z)}, args: {connection_id: "stub", certificate_id: "stub"}},
+    {name: :list_connection_saml_sp_signing_cert, verb: :get, url: %r{\Ahttps://api\.workos\.com/connections/stub/saml_sp_signing_cert(\?|\z)}, args: {connection_id: "stub"}},
+    {name: :create_connection_saml_sp_signing_cert, verb: :post, url: %r{\Ahttps://api\.workos\.com/connections/stub/saml_sp_signing_cert(\?|\z)}, args: {connection_id: "stub"}},
+    {name: :delete_connection_saml_sp_signing_cert, verb: :delete, url: %r{\Ahttps://api\.workos\.com/connections/stub/saml_sp_signing_cert/stub(\?|\z)}, args: {connection_id: "stub", certificate_id: "stub"}},
     {name: :get_connection, verb: :get, url: %r{\Ahttps://api\.workos\.com/connections/stub(\?|\z)}, args: {id: "stub"}},
+    {name: :update_connection, verb: :patch, url: %r{\Ahttps://api\.workos\.com/connections/stub(\?|\z)}, args: {id: "stub", protocol_options: WorkOS::SSO::PatchProtocolOptionsSAML.new(saml_options: {})}},
     {name: :delete_connection, verb: :delete, url: %r{\Ahttps://api\.workos\.com/connections/stub(\?|\z)}, args: {id: "stub"}},
     {name: :authorize_logout, verb: :post, url: %r{\Ahttps://api\.workos\.com/sso/logout/authorize(\?|\z)}, args: {profile_id: "stub"}},
     {name: :get_profile, verb: :get, url: %r{\Ahttps://api\.workos\.com/sso/profile(\?|\z)}},
-    {name: :get_profile_and_token, verb: :post, url: %r{\Ahttps://api\.workos\.com/sso/token(\?|\z)}, args: {code: "stub"}}
+    {name: :get_profile_and_token, verb: :post, url: %r{\Ahttps://api\.workos\.com/sso/token(\?|\z)}}
   ].each do |spec|
     define_method("test_#{spec[:name]}_raises_authentication_error_on_401") do
       stub_request(spec[:verb], spec[:url])

data/test/workos/test_sso_model_round_trip.rb

@@ -5,19 +5,197 @@
 require "test_helper"
 
 class SsoModelRoundTripTest < Minitest::Test
+  def test_create_connection_key_pair_round_trip
+    fixture = {
+      "key" => "stub",
+      "cert" => "stub"
+    }
+    model = WorkOS::CreateConnectionKeyPair.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["key"], json[:key]
+    assert_equal fixture["cert"], json[:cert]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_create_connection_saml_options_round_trip
+    fixture = {
+      "idp_metadata_url" => "stub",
+      "acs_url" => "stub",
+      "sp_entity_id" => "stub",
+      "idp_entity_id" => "stub",
+      "idp_sso_url" => "stub",
+      "idp_signing_certs" => [],
+      "sp_signing_key_pair" => {},
+      "sp_encryption_key_pairs" => []
+    }
+    model = WorkOS::CreateConnectionSAMLOptions.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_create_connection_oidc_options_round_trip
+    fixture = {
+      "discovery_endpoint" => "stub",
+      "client_id" => "stub",
+      "client_secret" => "stub",
+      "redirect_uri" => "stub",
+      "pkce" => true,
+      "token_authentication_method" => "stub",
+      "jwt_signing_key_pair" => {},
+      "id_token_signature_algorithm" => "stub",
+      "fetch_user_info" => true
+    }
+    model = WorkOS::CreateConnectionOIDCOptions.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["discovery_endpoint"], json[:discovery_endpoint]
+    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_create_connection_standard_attributes_round_trip
+    fixture = {
+      "idp_id" => "stub",
+      "email" => "stub",
+      "first_name" => "stub",
+      "last_name" => "stub",
+      "groups" => nil,
+      "name" => nil
+    }
+    model = WorkOS::CreateConnectionStandardAttributes.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_create_connection_attribute_maps_round_trip
+    fixture = {
+      "standard_attributes" => {},
+      "custom_attributes" => {}
+    }
+    model = WorkOS::CreateConnectionAttributeMaps.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_create_connection_round_trip
+    fixture = {
+      "organization_id" => "stub",
+      "name" => "stub",
+      "external_id" => "stub",
+      "connection_type" => "stub",
+      "attribute_maps" => {},
+      "saml_options" => {},
+      "oidc_options" => {}
+    }
+    model = WorkOS::CreateConnection.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    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_patch_connection_saml_options_round_trip
+    fixture = {
+      "idp_metadata_url" => nil,
+      "acs_url" => nil,
+      "sp_entity_id" => nil,
+      "idp_entity_id" => "stub",
+      "idp_sso_url" => "stub"
+    }
+    model = WorkOS::PatchConnectionSAMLOptions.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_patch_connection_oidc_options_round_trip
+    fixture = {
+      "discovery_endpoint" => "stub",
+      "client_id" => "stub",
+      "client_secret" => "stub",
+      "redirect_uri" => nil,
+      "pkce" => true,
+      "token_authentication_method" => "stub",
+      "id_token_signature_algorithm" => "stub",
+      "fetch_user_info" => true
+    }
+    model = WorkOS::PatchConnectionOIDCOptions.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_patch_connection_standard_attributes_round_trip
+    fixture = {
+      "idp_id" => "stub",
+      "email" => "stub",
+      "first_name" => "stub",
+      "last_name" => "stub",
+      "groups" => nil,
+      "name" => nil
+    }
+    model = WorkOS::PatchConnectionStandardAttributes.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_patch_connection_attribute_maps_round_trip
+    fixture = {
+      "standard_attributes" => {},
+      "custom_attributes" => {}
+    }
+    model = WorkOS::PatchConnectionAttributeMaps.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_patch_connection_round_trip
+    fixture = {
+      "name" => "stub",
+      "external_id" => nil,
+      "connection_type" => "stub",
+      "attribute_maps" => {},
+      "saml_options" => {},
+      "oidc_options" => {}
+    }
+    model = WorkOS::PatchConnection.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_create_saml_idp_signing_certificate_round_trip
+    fixture = {
+      "value" => "stub"
+    }
+    model = WorkOS::CreateSAMLIdpSigningCertificate.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["value"], json[:value]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
   def test_token_query_round_trip
     fixture = {
       "client_id" => "stub",
       "client_secret" => "stub",
       "code" => "stub",
-      "grant_type" => "authorization_code"
+      "grant_type" => "stub",
+      "subject_token" => "stub",
+      "subject_token_type" => "urn:ietf:params:oauth:token-type:id_token",
+      "organization_id" => "stub"
     }
     model = WorkOS::TokenQuery.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]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
@@ -304,6 +482,88 @@ class SsoModelRoundTripTest < 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_saml_idp_signing_certificate_round_trip
+    fixture = {
+      "object" => "saml_idp_signing_certificate",
+      "id" => "stub",
+      "value" => "stub",
+      "not_before" => nil,
+      "not_after" => nil,
+      "created_at" => "stub"
+    }
+    model = WorkOS::SAMLIdpSigningCertificate.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["value"], json[:value]
+    assert_nil json[:not_before]
+    assert_nil json[:not_after]
+    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_saml_idp_signing_certificate_list_round_trip
+    fixture = {
+      "object" => "list",
+      "data" => []
+    }
+    model = WorkOS::SAMLIdpSigningCertificateList.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_saml_sp_encryption_certificate_round_trip
+    fixture = {
+      "object" => "saml_sp_encryption_certificate",
+      "id" => "stub",
+      "value" => "stub",
+      "not_before" => nil,
+      "not_after" => nil,
+      "created_at" => "stub"
+    }
+    model = WorkOS::SAMLSpEncryptionCertificate.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["value"], json[:value]
+    assert_nil json[:not_before]
+    assert_nil json[:not_after]
+    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_saml_sp_encryption_certificate_list_round_trip
+    fixture = {
+      "object" => "list",
+      "data" => []
+    }
+    model = WorkOS::SAMLSpEncryptionCertificateList.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_saml_sp_signing_certificate_round_trip
+    fixture = {
+      "object" => "saml_sp_signing_certificate",
+      "id" => "stub",
+      "value" => "stub",
+      "not_before" => nil,
+      "not_after" => nil,
+      "created_at" => "stub"
+    }
+    model = WorkOS::SAMLSpSigningCertificate.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["value"], json[:value]
+    assert_nil json[:not_before]
+    assert_nil json[:not_after]
+    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_sso_authorize_url_response_round_trip
     fixture = {
       "url" => "stub"

data/test/workos/test_user_management.rb

@@ -459,6 +459,55 @@ class UserManagementTest < Minitest::Test
     assert_nil result
   end
 
+  def test_delete_waitlist_entry_returns_expected_result
+    stub_request(:delete, %r{\Ahttps://api\.workos\.com/user_management/waitlist_entries/stub(\?|\z)})
+      .to_return(body: "{}", status: 200)
+    result = @client.user_management.delete_waitlist_entry(id: "stub")
+    assert_nil result
+  end
+
+  def test_create_waitlist_entry_approve_returns_expected_result
+    stub_request(:post, %r{\Ahttps://api\.workos\.com/user_management/waitlist_entries/stub/approve(\?|\z)})
+      .to_return(body: "{}", status: 200)
+    result = @client.user_management.create_waitlist_entry_approve(id: "stub")
+    refute_nil result
+  end
+
+  def test_create_waitlist_entry_deny_returns_expected_result
+    stub_request(:post, %r{\Ahttps://api\.workos\.com/user_management/waitlist_entries/stub/deny(\?|\z)})
+      .to_return(body: "{}", status: 200)
+    result = @client.user_management.create_waitlist_entry_deny(id: "stub")
+    refute_nil result
+  end
+
+  def test_list_waitlists_returns_expected_result
+    stub_request(:get, %r{\Ahttps://api\.workos\.com/user_management/waitlists(\?|\z)})
+      .to_return(body: '{"data": [], "list_metadata": {}}', status: 200)
+    result = @client.user_management.list_waitlists
+    assert_kind_of WorkOS::Types::ListStruct, result
+  end
+
+  def test_get_waitlist_returns_expected_result
+    stub_request(:get, %r{\Ahttps://api\.workos\.com/user_management/waitlists/stub(\?|\z)})
+      .to_return(body: "{}", status: 200)
+    result = @client.user_management.get_waitlist(id: "stub")
+    refute_nil result
+  end
+
+  def test_list_waitlist_entries_returns_expected_result
+    stub_request(:get, %r{\Ahttps://api\.workos\.com/user_management/waitlists/stub/entries(\?|\z)})
+      .to_return(body: '{"data": [], "list_metadata": {}}', status: 200)
+    result = @client.user_management.list_waitlist_entries(id: "stub")
+    assert_kind_of WorkOS::Types::ListStruct, result
+  end
+
+  def test_create_waitlist_entry_returns_expected_result
+    stub_request(:post, %r{\Ahttps://api\.workos\.com/user_management/waitlists/stub/entries(\?|\z)})
+      .to_return(body: "{}", status: 200)
+    result = @client.user_management.create_waitlist_entry(id: "stub", email: "stub")
+    refute_nil result
+  end
+
   def test_list_user_api_keys_returns_expected_result
     stub_request(:get, %r{\Ahttps://api\.workos\.com/user_management/users/stub/api_keys(\?|\z)})
       .to_return(body: '{"data": [], "list_metadata": {}}', status: 200)
@@ -515,6 +564,13 @@ class UserManagementTest < Minitest::Test
     {name: :delete_redirect_uris, verb: :delete, url: %r{\Ahttps://api\.workos\.com/user_management/redirect_uris/stub(\?|\z)}, args: {id: "stub"}},
     {name: :list_user_authorized_applications, verb: :get, url: %r{\Ahttps://api\.workos\.com/user_management/users/stub/authorized_applications(\?|\z)}, args: {user_id: "stub"}},
     {name: :delete_user_authorized_application, verb: :delete, url: %r{\Ahttps://api\.workos\.com/user_management/users/stub/authorized_applications/stub(\?|\z)}, args: {application_id: "stub", user_id: "stub"}},
+    {name: :delete_waitlist_entry, verb: :delete, url: %r{\Ahttps://api\.workos\.com/user_management/waitlist_entries/stub(\?|\z)}, args: {id: "stub"}},
+    {name: :create_waitlist_entry_approve, verb: :post, url: %r{\Ahttps://api\.workos\.com/user_management/waitlist_entries/stub/approve(\?|\z)}, args: {id: "stub"}},
+    {name: :create_waitlist_entry_deny, verb: :post, url: %r{\Ahttps://api\.workos\.com/user_management/waitlist_entries/stub/deny(\?|\z)}, args: {id: "stub"}},
+    {name: :list_waitlists, verb: :get, url: %r{\Ahttps://api\.workos\.com/user_management/waitlists(\?|\z)}},
+    {name: :get_waitlist, verb: :get, url: %r{\Ahttps://api\.workos\.com/user_management/waitlists/stub(\?|\z)}, args: {id: "stub"}},
+    {name: :list_waitlist_entries, verb: :get, url: %r{\Ahttps://api\.workos\.com/user_management/waitlists/stub/entries(\?|\z)}, args: {id: "stub"}},
+    {name: :create_waitlist_entry, verb: :post, url: %r{\Ahttps://api\.workos\.com/user_management/waitlists/stub/entries(\?|\z)}, args: {id: "stub", email: "stub"}},
     {name: :list_user_api_keys, verb: :get, url: %r{\Ahttps://api\.workos\.com/user_management/users/stub/api_keys(\?|\z)}, args: {user_id: "stub"}},
     {name: :create_user_api_key, verb: :post, url: %r{\Ahttps://api\.workos\.com/user_management/users/stub/api_keys(\?|\z)}, args: {user_id: "stub", name: "stub", organization_id: "stub"}}
   ].each do |spec|

data/test/workos/test_user_management_model_round_trip.rb

@@ -225,6 +225,19 @@ class UserManagementModelRoundTripTest < 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_create_waitlist_entry_round_trip
+    fixture = {
+      "email" => "stub",
+      "additional_fields" => {},
+      "send_confirmation_email" => true
+    }
+    model = WorkOS::CreateWaitlistEntry.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    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_user_round_trip
     fixture = {
       "object" => "user",
@@ -683,7 +696,8 @@ class UserManagementModelRoundTripTest < Minitest::Test
       "user_agent" => nil,
       "user_id" => nil,
       "email" => nil,
-      "error" => {}
+      "error" => {},
+      "provider" => "stub"
     }
     model = WorkOS::AuthenticationOAuthFailedData.new(fixture.to_json)
     json = model.to_h
@@ -732,7 +746,8 @@ class UserManagementModelRoundTripTest < Minitest::Test
       "ip_address" => nil,
       "user_agent" => nil,
       "user_id" => nil,
-      "email" => "stub"
+      "email" => "stub",
+      "provider" => "stub"
     }
     model = WorkOS::AuthenticationOAuthSucceededData.new(fixture.to_json)
     json = model.to_h
@@ -2058,6 +2073,45 @@ class UserManagementModelRoundTripTest < 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_waitlist_round_trip
+    fixture = {
+      "object" => "waitlist",
+      "id" => "stub",
+      "created_at" => "stub",
+      "updated_at" => "stub"
+    }
+    model = WorkOS::Waitlist.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["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_entry_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_entry"
+    }
+    model = WorkOS::WaitlistEntry.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_jwks_response_round_trip
     fixture = {
       "keys" => []
@@ -2295,6 +2349,28 @@ class UserManagementModelRoundTripTest < 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_email_completion_session_authenticate_request_round_trip
+    fixture = {
+      "client_id" => "stub",
+      "client_secret" => "stub",
+      "grant_type" => "urn:workos:oauth:grant-type:email-completion",
+      "email_completion_token" => "stub",
+      "email" => "stub",
+      "ip_address" => "stub",
+      "device_id" => "stub",
+      "user_agent" => "stub",
+      "signals_id" => "stub"
+    }
+    model = WorkOS::EmailCompletionSessionAuthenticateRequest.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["email_completion_token"], json[:email_completion_token]
+    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_organization_selection_session_authenticate_request_round_trip
     fixture = {
       "client_id" => "stub",