@riffdb/better-auth 0.2.0 → 0.2.1

package/generated/rust/client.rs

@@ -6,11 +6,11 @@ pub use riffdb_client_rust::QueryOptions;
 use riffdb_client_rust::v1::value::Kind as WireKind;
 
 use riffdb_client_rust::app_v1;
-pub const QUERY_MODULE_HASH: [u8; 32] = [0x18, 0xcf, 0xd9, 0x99, 0x21, 0x40, 0x6e, 0x15, 0x72, 0x2f, 0x3a, 0xc4, 0x58, 0x67, 0xd3, 0xfb, 0xe0, 0xce, 0xbd, 0x4f, 0x2e, 0xcd, 0xd8, 0x6c, 0x0b, 0xa0, 0x99, 0x54, 0x7c, 0x58, 0xcd, 0x91];
+pub const QUERY_MODULE_HASH: [u8; 32] = [0x8d, 0xff, 0x3a, 0x38, 0xf6, 0xc0, 0xa9, 0x15, 0xd7, 0x65, 0x3e, 0x75, 0x71, 0xa2, 0xef, 0x57, 0x95, 0xa8, 0x9b, 0x45, 0x29, 0x90, 0xd7, 0x05, 0xf3, 0x8f, 0xe0, 0xac, 0x93, 0xb5, 0xad, 0x9a];
 pub const CONTRACT_LINEAGE: &str = "RiffDBBetterAuthCore";
 pub const CONTRACT_VERSION: u64 = 1;
 
-pub const CONTRACT_BUNDLE_HASH: [u8; 32] = [0x11, 0xc5, 0xa3, 0x77, 0x24, 0xf4, 0x0b, 0x92, 0xbf, 0x10, 0xb1, 0x95, 0xe6, 0xa6, 0x6e, 0xf3, 0x00, 0x37, 0xf7, 0x3f, 0x3d, 0xf7, 0x9a, 0x98, 0xe4, 0xc4, 0xed, 0x10, 0x76, 0x88, 0x3d, 0x2e];
+pub const CONTRACT_BUNDLE_HASH: [u8; 32] = [0x74, 0xfd, 0x25, 0x5e, 0xef, 0xcf, 0x04, 0xf0, 0xb0, 0x54, 0xdb, 0xb6, 0xc4, 0xa0, 0xbe, 0xd4, 0x3a, 0x73, 0x12, 0xd8, 0x2f, 0x77, 0x55, 0x68, 0x7c, 0x92, 0x29, 0xee, 0x32, 0x06, 0xdd, 0xfc];
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct DecimalValue {
@@ -93,7 +93,7 @@ impl AdminUsersAllEmailAscResult {
     }
 }
 
-pub const ADMIN_USERS_ALL_EMAIL_ASC_QUERY_PLAN_HASH: [u8; 32] = [0xea, 0x50, 0x56, 0xdf, 0x11, 0x64, 0x18, 0x32, 0x9d, 0x03, 0xbc, 0x53, 0x6a, 0x19, 0x52, 0x47, 0x14, 0x83, 0x60, 0x37, 0x8e, 0x11, 0x44, 0x4c, 0x10, 0xe7, 0xca, 0x37, 0xdf, 0x54, 0xc5, 0x47];
+pub const ADMIN_USERS_ALL_EMAIL_ASC_QUERY_PLAN_HASH: [u8; 32] = [0x05, 0x6e, 0xdb, 0xaa, 0xbe, 0x43, 0xe1, 0xdc, 0x95, 0xf1, 0xf6, 0xaf, 0x98, 0x38, 0x74, 0x7f, 0x54, 0xd9, 0x27, 0xa9, 0x0d, 0x5b, 0xc9, 0xf2, 0xbe, 0x04, 0x5a, 0xe2, 0x66, 0xd1, 0x07, 0xd3];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct AdminUsersAllEmailAscQuery(pub AdminUsersAllEmailAscParams);
 impl GeneratedQuery for AdminUsersAllEmailAscQuery {
@@ -224,7 +224,7 @@ impl AdminUsersContainsAscResult {
     }
 }
 
-pub const ADMIN_USERS_CONTAINS_ASC_QUERY_PLAN_HASH: [u8; 32] = [0x56, 0x13, 0x2d, 0x4a, 0x48, 0xf4, 0x37, 0x31, 0xe3, 0x6b, 0x69, 0xe0, 0xfe, 0x92, 0x2d, 0x67, 0x49, 0x1b, 0xc0, 0xad, 0x61, 0x13, 0x75, 0xfb, 0xc3, 0xd3, 0x72, 0xa8, 0x40, 0xb7, 0x39, 0xdf];
+pub const ADMIN_USERS_CONTAINS_ASC_QUERY_PLAN_HASH: [u8; 32] = [0xb6, 0x4d, 0x21, 0x34, 0x77, 0xdd, 0x22, 0x75, 0xd9, 0x84, 0x22, 0xa6, 0xc3, 0x46, 0x0b, 0x0c, 0xae, 0x93, 0x2d, 0xd9, 0x62, 0x55, 0xfe, 0x9d, 0x56, 0x50, 0x05, 0xe8, 0xaf, 0xa3, 0x7f, 0xc4];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct AdminUsersContainsAscQuery(pub AdminUsersContainsAscParams);
 impl GeneratedQuery for AdminUsersContainsAscQuery {
@@ -355,7 +355,7 @@ impl AdminUsersContainsDescResult {
     }
 }
 
-pub const ADMIN_USERS_CONTAINS_DESC_QUERY_PLAN_HASH: [u8; 32] = [0x47, 0x0b, 0x72, 0x0e, 0x68, 0xaa, 0x22, 0x61, 0xd9, 0x02, 0x37, 0x8e, 0xbc, 0x7f, 0xb1, 0xce, 0x5b, 0xe5, 0x15, 0x82, 0x76, 0x16, 0x72, 0xda, 0x7e, 0xcb, 0x87, 0xbe, 0xce, 0x97, 0x7f, 0x0f];
+pub const ADMIN_USERS_CONTAINS_DESC_QUERY_PLAN_HASH: [u8; 32] = [0x57, 0xab, 0xa8, 0xcf, 0x31, 0x1c, 0x30, 0x1e, 0x98, 0x5a, 0xdc, 0x32, 0x4f, 0x97, 0xb4, 0xd9, 0x63, 0xa3, 0x8e, 0x6e, 0xfa, 0x60, 0x58, 0xa8, 0x2e, 0x24, 0x88, 0x54, 0xd7, 0x5f, 0x2f, 0x05];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct AdminUsersContainsDescQuery(pub AdminUsersContainsDescParams);
 impl GeneratedQuery for AdminUsersContainsDescQuery {
@@ -486,7 +486,7 @@ impl AdminUsersEmailContainsCreatedDescResult {
     }
 }
 
-pub const ADMIN_USERS_EMAIL_CONTAINS_CREATED_DESC_QUERY_PLAN_HASH: [u8; 32] = [0x51, 0xde, 0xf4, 0x48, 0x8f, 0xf2, 0xa3, 0x5f, 0xee, 0x0c, 0x5d, 0x7f, 0x26, 0x7d, 0xaa, 0xca, 0x11, 0xe6, 0x0a, 0x03, 0x52, 0x1b, 0xe0, 0xfd, 0xaf, 0x89, 0x23, 0xc5, 0x48, 0x6c, 0x54, 0x85];
+pub const ADMIN_USERS_EMAIL_CONTAINS_CREATED_DESC_QUERY_PLAN_HASH: [u8; 32] = [0x7a, 0xed, 0xe9, 0xed, 0xa6, 0x24, 0xf5, 0xb4, 0xeb, 0x42, 0x80, 0xca, 0x7b, 0x8a, 0x14, 0x21, 0x46, 0x6c, 0xe3, 0x00, 0x91, 0x17, 0x7c, 0x9a, 0xba, 0xb4, 0xf1, 0x25, 0x98, 0x7e, 0xb4, 0xff];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct AdminUsersEmailContainsCreatedDescQuery(pub AdminUsersEmailContainsCreatedDescParams);
 impl GeneratedQuery for AdminUsersEmailContainsCreatedDescQuery {
@@ -617,7 +617,7 @@ impl AdminUsersEmailContainsImageAscResult {
     }
 }
 
-pub const ADMIN_USERS_EMAIL_CONTAINS_IMAGE_ASC_QUERY_PLAN_HASH: [u8; 32] = [0xfd, 0x5d, 0xc8, 0x60, 0x99, 0x56, 0x71, 0x13, 0xdc, 0xce, 0x8e, 0xf6, 0x1c, 0x28, 0x0b, 0x22, 0xf3, 0x5a, 0x2c, 0x3b, 0x9e, 0x6f, 0xc5, 0x92, 0xf0, 0xbc, 0xfa, 0xde, 0xd4, 0x00, 0x8f, 0x80];
+pub const ADMIN_USERS_EMAIL_CONTAINS_IMAGE_ASC_QUERY_PLAN_HASH: [u8; 32] = [0x45, 0x3c, 0xb6, 0xc8, 0x1f, 0x50, 0x6a, 0x1f, 0x0a, 0xc9, 0x9b, 0xed, 0x3c, 0xc8, 0x5d, 0xa5, 0x91, 0x76, 0xd2, 0xcb, 0x83, 0x59, 0x7d, 0x58, 0x12, 0xd7, 0x71, 0x68, 0x3a, 0x60, 0xcb, 0x4c];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct AdminUsersEmailContainsImageAscQuery(pub AdminUsersEmailContainsImageAscParams);
 impl GeneratedQuery for AdminUsersEmailContainsImageAscQuery {
@@ -748,7 +748,7 @@ impl AdminUsersEndsWithAscResult {
     }
 }
 
-pub const ADMIN_USERS_ENDS_WITH_ASC_QUERY_PLAN_HASH: [u8; 32] = [0xa8, 0x32, 0x29, 0x24, 0x9d, 0xf9, 0x61, 0xab, 0xbc, 0x11, 0x3e, 0x7b, 0x80, 0x8a, 0xf6, 0xbe, 0xca, 0x7c, 0xa9, 0x15, 0x83, 0x5d, 0xdc, 0xd0, 0x6c, 0xd5, 0xc2, 0x8b, 0xb7, 0xd3, 0xc9, 0x20];
+pub const ADMIN_USERS_ENDS_WITH_ASC_QUERY_PLAN_HASH: [u8; 32] = [0x92, 0x4c, 0x7a, 0xcf, 0xdc, 0xf3, 0xf7, 0x97, 0x09, 0x17, 0xac, 0x61, 0x1b, 0x6e, 0xaf, 0xc9, 0x17, 0x5a, 0xc6, 0x9f, 0x73, 0x5d, 0x9e, 0x1c, 0xc0, 0x14, 0x14, 0xfc, 0xc6, 0xf0, 0xe6, 0x96];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct AdminUsersEndsWithAscQuery(pub AdminUsersEndsWithAscParams);
 impl GeneratedQuery for AdminUsersEndsWithAscQuery {
@@ -879,7 +879,7 @@ impl AdminUsersEndsWithDescResult {
     }
 }
 
-pub const ADMIN_USERS_ENDS_WITH_DESC_QUERY_PLAN_HASH: [u8; 32] = [0xac, 0x6f, 0xdf, 0xac, 0xb6, 0xf3, 0x6e, 0x2a, 0x68, 0xe3, 0x64, 0x29, 0x17, 0x1b, 0x5d, 0x8d, 0x50, 0x2b, 0x2f, 0xd4, 0x3f, 0x78, 0x1d, 0x72, 0x54, 0x1e, 0xce, 0x96, 0x1f, 0x1d, 0xa9, 0x3c];
+pub const ADMIN_USERS_ENDS_WITH_DESC_QUERY_PLAN_HASH: [u8; 32] = [0xca, 0xb8, 0xad, 0x84, 0x56, 0x53, 0x3e, 0x4c, 0xe9, 0x73, 0x88, 0x94, 0x8e, 0x4f, 0x70, 0x3c, 0xac, 0x6f, 0x2e, 0xeb, 0xb6, 0x41, 0xb8, 0x3a, 0x91, 0xc3, 0xb0, 0x05, 0xec, 0xe7, 0xff, 0xfb];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct AdminUsersEndsWithDescQuery(pub AdminUsersEndsWithDescParams);
 impl GeneratedQuery for AdminUsersEndsWithDescQuery {
@@ -1010,7 +1010,7 @@ impl AdminUsersStartsWithAscResult {
     }
 }
 
-pub const ADMIN_USERS_STARTS_WITH_ASC_QUERY_PLAN_HASH: [u8; 32] = [0xe9, 0x59, 0x4b, 0x9b, 0x96, 0x31, 0xb7, 0x8e, 0x8c, 0xbd, 0x9a, 0x89, 0xc4, 0xa2, 0xf1, 0xb4, 0x3c, 0xb4, 0x0b, 0x62, 0xef, 0x55, 0xbb, 0x18, 0xb7, 0x04, 0xf7, 0x90, 0x04, 0x4b, 0x23, 0x32];
+pub const ADMIN_USERS_STARTS_WITH_ASC_QUERY_PLAN_HASH: [u8; 32] = [0xad, 0xd0, 0xae, 0xd3, 0xdb, 0xd0, 0xca, 0xea, 0x0d, 0xe2, 0x85, 0x71, 0x33, 0xa8, 0x57, 0xd4, 0x9e, 0xb7, 0xbf, 0xc0, 0xe0, 0x31, 0xd1, 0x17, 0x27, 0x0c, 0xc8, 0x73, 0x13, 0x7d, 0xa5, 0xec];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct AdminUsersStartsWithAscQuery(pub AdminUsersStartsWithAscParams);
 impl GeneratedQuery for AdminUsersStartsWithAscQuery {
@@ -1141,7 +1141,7 @@ impl AdminUsersStartsWithDescResult {
     }
 }
 
-pub const ADMIN_USERS_STARTS_WITH_DESC_QUERY_PLAN_HASH: [u8; 32] = [0x1f, 0x52, 0xbc, 0xc4, 0xf1, 0xf3, 0xe7, 0x78, 0xf3, 0x3e, 0x3e, 0x47, 0x29, 0x90, 0x09, 0xce, 0x70, 0xd3, 0xf4, 0xc5, 0x41, 0xd1, 0xbe, 0xd3, 0x5e, 0x6f, 0x95, 0x3d, 0x0e, 0x79, 0xff, 0xea];
+pub const ADMIN_USERS_STARTS_WITH_DESC_QUERY_PLAN_HASH: [u8; 32] = [0x23, 0xc1, 0x56, 0x1f, 0xb3, 0x95, 0x62, 0x17, 0xe7, 0x9d, 0x1b, 0x35, 0x8b, 0xe4, 0x68, 0xe5, 0x5c, 0x40, 0x21, 0xb8, 0x87, 0xe9, 0x27, 0xa4, 0xfb, 0x3c, 0x04, 0x84, 0xc9, 0x2b, 0xe8, 0x72];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct AdminUsersStartsWithDescQuery(pub AdminUsersStartsWithDescParams);
 impl GeneratedQuery for AdminUsersStartsWithDescQuery {
@@ -1290,7 +1290,7 @@ impl FindAccountByIdResult {
     }
 }
 
-pub const FIND_ACCOUNT_BY_ID_QUERY_PLAN_HASH: [u8; 32] = [0x51, 0xec, 0xe0, 0xc8, 0xe7, 0x39, 0x6f, 0x3f, 0x9e, 0xfe, 0xa7, 0x59, 0x5a, 0x42, 0x24, 0xf8, 0x56, 0xae, 0x79, 0x84, 0xff, 0x9b, 0xf1, 0x5b, 0xcf, 0x90, 0x49, 0x42, 0x7a, 0xd1, 0xf1, 0x10];
+pub const FIND_ACCOUNT_BY_ID_QUERY_PLAN_HASH: [u8; 32] = [0x14, 0xa0, 0x8d, 0xf3, 0xdd, 0x8a, 0x74, 0xea, 0x0a, 0x56, 0x22, 0x80, 0x4b, 0xf0, 0xc2, 0x42, 0x40, 0x86, 0xee, 0x73, 0xeb, 0x10, 0xce, 0x57, 0xd7, 0xdf, 0x33, 0x6a, 0x7d, 0x25, 0xf5, 0xba];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct FindAccountByIdQuery(pub FindAccountByIdParams);
 impl GeneratedQuery for FindAccountByIdQuery {
@@ -1432,7 +1432,7 @@ impl FindAccountByProviderResult {
     }
 }
 
-pub const FIND_ACCOUNT_BY_PROVIDER_QUERY_PLAN_HASH: [u8; 32] = [0xb1, 0x04, 0xb3, 0x80, 0x50, 0x39, 0x6d, 0x74, 0x7e, 0x59, 0x73, 0x5c, 0xea, 0x4b, 0x56, 0x2c, 0x30, 0x5d, 0xcc, 0xb7, 0x61, 0x4a, 0x97, 0x3f, 0x51, 0x77, 0x50, 0x18, 0x25, 0xc9, 0x10, 0x89];
+pub const FIND_ACCOUNT_BY_PROVIDER_QUERY_PLAN_HASH: [u8; 32] = [0xe6, 0xc4, 0x51, 0x7a, 0x46, 0xd7, 0x25, 0x78, 0x0e, 0x79, 0x72, 0x5c, 0xa3, 0xfd, 0xab, 0xa2, 0x20, 0x8e, 0xf4, 0xb2, 0x82, 0xd4, 0x9f, 0x48, 0x41, 0x21, 0xee, 0xe7, 0x6c, 0x04, 0x38, 0x31];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct FindAccountByProviderQuery(pub FindAccountByProviderParams);
 impl GeneratedQuery for FindAccountByProviderQuery {
@@ -1575,7 +1575,7 @@ impl FindAccountsByUserIdResult {
     }
 }
 
-pub const FIND_ACCOUNTS_BY_USER_ID_QUERY_PLAN_HASH: [u8; 32] = [0x0e, 0x51, 0x7c, 0x2b, 0x2a, 0x10, 0xd9, 0x5c, 0x12, 0x81, 0x2d, 0x63, 0x74, 0x10, 0x73, 0x79, 0xc8, 0x0c, 0xe4, 0x63, 0x8b, 0x96, 0x2f, 0xad, 0x6f, 0x90, 0x92, 0xcc, 0x6b, 0x8b, 0x6c, 0x2e];
+pub const FIND_ACCOUNTS_BY_USER_ID_QUERY_PLAN_HASH: [u8; 32] = [0xcc, 0xdc, 0x52, 0x4c, 0xa6, 0x4a, 0xd6, 0x67, 0xc2, 0x09, 0xde, 0x25, 0xb4, 0xce, 0x97, 0x7f, 0x43, 0xb5, 0x3f, 0xfd, 0xd8, 0xeb, 0x1b, 0x70, 0xfe, 0xdf, 0x29, 0xfc, 0x99, 0xf2, 0x7d, 0xa6];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct FindAccountsByUserIdQuery(pub FindAccountsByUserIdParams);
 impl GeneratedQuery for FindAccountsByUserIdQuery {
@@ -1720,7 +1720,7 @@ impl FindAccountsByUserProviderResult {
     }
 }
 
-pub const FIND_ACCOUNTS_BY_USER_PROVIDER_QUERY_PLAN_HASH: [u8; 32] = [0x44, 0x12, 0x4f, 0xb1, 0x9b, 0x8f, 0x7f, 0xe3, 0x5b, 0xb1, 0x58, 0x24, 0xb8, 0x7a, 0x0e, 0xd5, 0x93, 0xc8, 0x6b, 0x58, 0x21, 0xe8, 0x1a, 0xd7, 0xfa, 0xe1, 0xab, 0x86, 0x36, 0x72, 0x51, 0x83];
+pub const FIND_ACCOUNTS_BY_USER_PROVIDER_QUERY_PLAN_HASH: [u8; 32] = [0x21, 0xd1, 0x3b, 0x3c, 0x30, 0xb4, 0xa4, 0x05, 0x9f, 0x3c, 0x43, 0x6e, 0x29, 0x0d, 0x11, 0xc2, 0x0f, 0x0f, 0x1d, 0x11, 0x54, 0xe0, 0x5f, 0xb4, 0x8a, 0xe3, 0xdd, 0x0d, 0xa8, 0x82, 0x52, 0x6d];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct FindAccountsByUserProviderQuery(pub FindAccountsByUserProviderParams);
 impl GeneratedQuery for FindAccountsByUserProviderQuery {
@@ -1858,7 +1858,7 @@ impl FindActiveSessionsByUserIdResult {
     }
 }
 
-pub const FIND_ACTIVE_SESSIONS_BY_USER_ID_QUERY_PLAN_HASH: [u8; 32] = [0x21, 0x8d, 0xbd, 0xff, 0x73, 0xdc, 0xe6, 0x8b, 0xa4, 0x8b, 0x7f, 0x8a, 0x17, 0x97, 0x91, 0xe6, 0xb4, 0x61, 0x39, 0xee, 0x84, 0xda, 0x3e, 0xdb, 0xd9, 0x64, 0x38, 0x04, 0x5f, 0x60, 0xf8, 0xdc];
+pub const FIND_ACTIVE_SESSIONS_BY_USER_ID_QUERY_PLAN_HASH: [u8; 32] = [0xde, 0x1e, 0x52, 0x32, 0xa6, 0x4a, 0x32, 0x05, 0x76, 0x99, 0xb5, 0xac, 0x21, 0xf1, 0xb4, 0x3e, 0x69, 0xd7, 0x55, 0xa3, 0xc1, 0x43, 0x59, 0x5f, 0x90, 0x6f, 0xe6, 0x3e, 0x16, 0x14, 0x72, 0x64];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct FindActiveSessionsByUserIdQuery(pub FindActiveSessionsByUserIdParams);
 impl GeneratedQuery for FindActiveSessionsByUserIdQuery {
@@ -1915,6 +1915,153 @@ fn decode_find_active_sessions_by_user_id_found_sessions_record(mut record: Appl
     Ok(value)
 }
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct FindCredentialAccountParams {
+    pub organization_id: String,
+    pub user_id: String,
+    pub account_id: String,
+    pub provider_id: String,
+}
+
+pub const FIND_CREDENTIAL_ACCOUNT_SECRET_OUTPUTS: &[(&str, &str, &str)] = &[
+    ("FindCredentialAccount", "Account", "access_token"),
+    ("FindCredentialAccount", "Account", "refresh_token"),
+    ("FindCredentialAccount", "Account", "id_token"),
+    ("FindCredentialAccount", "Account", "password"),
+];
+
+#[derive(Clone, Eq, PartialEq)]
+pub struct FindCredentialAccountFoundAccounts {
+    pub organization_id: String,
+    pub user_id: String,
+    pub id: String,
+    pub account_id: String,
+    pub provider_id: String,
+    pub access_token: Option<String>,
+    pub refresh_token: Option<String>,
+    pub id_token: Option<String>,
+    pub password: Option<String>,
+    pub access_token_expires_at: Option<TimestampValue>,
+    pub refresh_token_expires_at: Option<TimestampValue>,
+    pub scope: Option<String>,
+    pub created_at: TimestampValue,
+    pub updated_at: TimestampValue,
+    pub revision: u64,
+}
+
+impl std::fmt::Debug for FindCredentialAccountFoundAccounts {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter.write_str("FindCredentialAccountFoundAccounts { <secret outputs redacted> }")
+    }
+}
+
+#[derive(Clone, Eq, PartialEq)]
+pub struct FindCredentialAccountFound {
+    pub accounts: Vec<FindCredentialAccountFoundAccounts>,
+}
+
+impl std::fmt::Debug for FindCredentialAccountFound {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter.write_str("FindCredentialAccountFound { <secret outputs redacted> }")
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum FindCredentialAccountResult {
+    Found(Box<FindCredentialAccountFound>),
+}
+
+#[allow(dead_code)]
+impl FindCredentialAccountResult {
+    #[must_use]
+    pub const fn is_found(&self) -> bool {
+        matches!(self, Self::Found(_))
+    }
+    #[must_use]
+    pub fn as_found(&self) -> Option<&FindCredentialAccountFound> {
+        match self {
+            Self::Found(value) => Some(value.as_ref()),
+            #[allow(unreachable_patterns)]
+            _ => None,
+        }
+    }
+    pub fn into_found(self) -> Result<FindCredentialAccountFound, Self> {
+        match self {
+            Self::Found(value) => Ok(*value),
+            #[allow(unreachable_patterns)]
+            other => Err(other),
+        }
+    }
+    pub fn unwrap_found(&self) -> Result<&FindCredentialAccountFound, ApplicationClientError> {
+        self.as_found().ok_or(ApplicationClientError::InvalidResponse)
+    }
+    pub fn unwrap_found_value(&self) -> Result<&Vec<FindCredentialAccountFoundAccounts>, ApplicationClientError> {
+        Ok(&self.unwrap_found()?.accounts)
+    }
+}
+
+pub const FIND_CREDENTIAL_ACCOUNT_QUERY_PLAN_HASH: [u8; 32] = [0xf9, 0x68, 0x27, 0x1d, 0x10, 0x3a, 0x76, 0xcc, 0x6b, 0x2a, 0x54, 0x96, 0xf5, 0xcc, 0xef, 0xfe, 0x4c, 0xff, 0x5a, 0xa3, 0x9d, 0x2a, 0x37, 0x03, 0x79, 0xb5, 0x18, 0xd8, 0xe7, 0xd9, 0x07, 0x71];
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct FindCredentialAccountQuery(pub FindCredentialAccountParams);
+impl GeneratedQuery for FindCredentialAccountQuery {
+    type Output = FindCredentialAccountResult;
+
+    fn named_query(self, options: QueryOptions) -> Result<NamedQuery, ApplicationClientError> {
+        let mut parameters = BTreeMap::new();
+        parameters.insert("organization_id".to_owned(), ApplicationValue::Uuid(ApplicationUuid::from_text(self.0.organization_id)?));
+        parameters.insert("user_id".to_owned(), ApplicationValue::Uuid(ApplicationUuid::from_text(self.0.user_id)?));
+        parameters.insert("account_id".to_owned(), ApplicationValue::String(self.0.account_id));
+        parameters.insert("provider_id".to_owned(), ApplicationValue::String(self.0.provider_id));
+        NamedQuery::new(
+            ApplicationContract::Exact {
+                lineage: CONTRACT_LINEAGE.to_owned(),
+                version: CONTRACT_VERSION,
+                bundle_hash: Some(CONTRACT_BUNDLE_HASH),
+            },
+            "FindCredentialAccount",
+            Some(QUERY_MODULE_HASH),
+            parameters,
+            None,
+        )?.expect_plan_hash(FIND_CREDENTIAL_ACCOUNT_QUERY_PLAN_HASH).with_options(options)
+    }
+
+    fn decode_result(mut response: NamedQueryResult) -> Result<Self::Output, ApplicationClientError> {
+        let outcome = response.outcome.clone();
+        match outcome.as_str() {
+            "Found" => {
+                let decoded = FindCredentialAccountFound {
+                    accounts: many_result_records(take_result_field(&mut response.fields, "accounts")?)?.into_iter().map(decode_find_credential_account_found_accounts_record).collect::<Result<Vec<_>, _>>()?,
+                };
+                if !response.fields.is_empty() { return Err(ApplicationClientError::InvalidResponse); }
+                Ok(FindCredentialAccountResult::Found(Box::new(decoded)))
+            },
+            _ => Err(ApplicationClientError::InvalidResponse),
+        }
+    }
+}
+
+fn decode_find_credential_account_found_accounts_record(mut record: ApplicationRecord) -> Result<FindCredentialAccountFoundAccounts, ApplicationClientError> {
+    let value = FindCredentialAccountFoundAccounts {
+        organization_id: application_uuid(take_application_value(&mut record.fields, "organization_id")?)?,
+        user_id: application_uuid(take_application_value(&mut record.fields, "user_id")?)?,
+        id: application_uuid(take_application_value(&mut record.fields, "id")?)?,
+        account_id: application_string(take_application_value(&mut record.fields, "account_id")?)?,
+        provider_id: application_string(take_application_value(&mut record.fields, "provider_id")?)?,
+        access_token: match take_application_value(&mut record.fields, "access_token")? { ApplicationValue::Null => None, value => Some(application_string(value)?) },
+        refresh_token: match take_application_value(&mut record.fields, "refresh_token")? { ApplicationValue::Null => None, value => Some(application_string(value)?) },
+        id_token: match take_application_value(&mut record.fields, "id_token")? { ApplicationValue::Null => None, value => Some(application_string(value)?) },
+        password: match take_application_value(&mut record.fields, "password")? { ApplicationValue::Null => None, value => Some(application_string(value)?) },
+        access_token_expires_at: match take_application_value(&mut record.fields, "access_token_expires_at")? { ApplicationValue::Null => None, value => Some(application_timestamp(value)?) },
+        refresh_token_expires_at: match take_application_value(&mut record.fields, "refresh_token_expires_at")? { ApplicationValue::Null => None, value => Some(application_timestamp(value)?) },
+        scope: match take_application_value(&mut record.fields, "scope")? { ApplicationValue::Null => None, value => Some(application_string(value)?) },
+        created_at: application_timestamp(take_application_value(&mut record.fields, "created_at")?)?,
+        updated_at: application_timestamp(take_application_value(&mut record.fields, "updated_at")?)?,
+        revision: application_u64(take_application_value(&mut record.fields, "revision")?)?,
+    };
+    if !record.fields.is_empty() { return Err(ApplicationClientError::InvalidResponse); }
+    Ok(value)
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct FindExpiredVerificationIdsParams {
     pub organization_id: String,
@@ -1966,7 +2113,7 @@ impl FindExpiredVerificationIdsResult {
     }
 }
 
-pub const FIND_EXPIRED_VERIFICATION_IDS_QUERY_PLAN_HASH: [u8; 32] = [0xe2, 0x4f, 0xe8, 0x2a, 0x3a, 0x72, 0x4a, 0x9d, 0x45, 0x04, 0x4d, 0xc6, 0x68, 0xd4, 0x50, 0xe6, 0x1b, 0x11, 0x77, 0xf5, 0x86, 0x64, 0x23, 0xc0, 0x7b, 0xd3, 0x31, 0x00, 0xd4, 0x94, 0x28, 0xc1];
+pub const FIND_EXPIRED_VERIFICATION_IDS_QUERY_PLAN_HASH: [u8; 32] = [0x6c, 0x79, 0x98, 0x50, 0xba, 0x3b, 0x2e, 0xb3, 0x22, 0x2a, 0xac, 0x85, 0xa7, 0x6f, 0x40, 0x49, 0x2c, 0x46, 0xde, 0x76, 0x87, 0x00, 0x75, 0xb0, 0x29, 0xf3, 0xb4, 0xac, 0x89, 0x7e, 0xd8, 0xb9];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct FindExpiredVerificationIdsQuery(pub FindExpiredVerificationIdsParams);
 impl GeneratedQuery for FindExpiredVerificationIdsQuery {
@@ -2086,7 +2233,7 @@ impl FindLatestVerificationResult {
     }
 }
 
-pub const FIND_LATEST_VERIFICATION_QUERY_PLAN_HASH: [u8; 32] = [0x54, 0x33, 0x62, 0x05, 0xfa, 0x31, 0x5d, 0xa7, 0x5d, 0x39, 0x0d, 0x06, 0x20, 0x55, 0x72, 0x3e, 0x36, 0xd0, 0x7e, 0xf6, 0x59, 0x6e, 0x19, 0xf7, 0x56, 0xd3, 0x19, 0xa8, 0xbc, 0x87, 0x50, 0x23];
+pub const FIND_LATEST_VERIFICATION_QUERY_PLAN_HASH: [u8; 32] = [0xb3, 0x83, 0x2c, 0x0a, 0x8a, 0x31, 0x6d, 0x3f, 0xcb, 0xc6, 0x2b, 0x38, 0x8f, 0xbe, 0x09, 0xce, 0xb6, 0x62, 0x4b, 0x55, 0x48, 0x21, 0x95, 0xf7, 0x64, 0x25, 0x53, 0x46, 0x7c, 0xba, 0x6f, 0xcb];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct FindLatestVerificationQuery(pub FindLatestVerificationParams);
 impl GeneratedQuery for FindLatestVerificationQuery {
@@ -2212,7 +2359,7 @@ impl FindSessionByIdResult {
     }
 }
 
-pub const FIND_SESSION_BY_ID_QUERY_PLAN_HASH: [u8; 32] = [0x65, 0x3c, 0xfa, 0xb6, 0xa7, 0x5b, 0x5e, 0x26, 0x24, 0x62, 0x0b, 0x0b, 0x55, 0x04, 0xb1, 0x9d, 0x36, 0xf7, 0x78, 0xc8, 0x77, 0x56, 0x06, 0xfa, 0x0f, 0x3b, 0xb0, 0xc1, 0xd5, 0x1e, 0x6b, 0xc0];
+pub const FIND_SESSION_BY_ID_QUERY_PLAN_HASH: [u8; 32] = [0xc9, 0x2e, 0xb2, 0x03, 0x5c, 0x0e, 0x3c, 0xa7, 0xde, 0xdb, 0xaa, 0x42, 0xa4, 0xe2, 0xef, 0xe7, 0xbc, 0x47, 0x86, 0xa6, 0x52, 0x13, 0x39, 0x4d, 0xa7, 0xf5, 0xd3, 0xbe, 0xb5, 0x79, 0xa2, 0xa1];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct FindSessionByIdQuery(pub FindSessionByIdParams);
 impl GeneratedQuery for FindSessionByIdQuery {
@@ -2340,7 +2487,7 @@ impl FindSessionByTokenResult {
     }
 }
 
-pub const FIND_SESSION_BY_TOKEN_QUERY_PLAN_HASH: [u8; 32] = [0xb5, 0xe7, 0x01, 0x70, 0x1b, 0x0a, 0xc9, 0x9b, 0x43, 0x28, 0x20, 0x00, 0x89, 0xb2, 0x50, 0x7f, 0x31, 0xc0, 0xbe, 0x55, 0xdf, 0x78, 0xa2, 0x75, 0xd8, 0x3f, 0x7b, 0xe9, 0x9f, 0x8b, 0x70, 0x61];
+pub const FIND_SESSION_BY_TOKEN_QUERY_PLAN_HASH: [u8; 32] = [0xa8, 0xa1, 0x23, 0x34, 0xa3, 0xd3, 0x4c, 0x30, 0xd5, 0x4b, 0xe8, 0x28, 0xbd, 0xcc, 0x9b, 0x9b, 0x77, 0x22, 0x33, 0x03, 0xc3, 0xf9, 0x68, 0x1e, 0x4a, 0x60, 0x2c, 0x92, 0x34, 0x18, 0x76, 0xec];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct FindSessionByTokenQuery(pub FindSessionByTokenParams);
 impl GeneratedQuery for FindSessionByTokenQuery {
@@ -2468,7 +2615,7 @@ impl FindSessionsByTokenSetResult {
     }
 }
 
-pub const FIND_SESSIONS_BY_TOKEN_SET_QUERY_PLAN_HASH: [u8; 32] = [0x56, 0xc6, 0x83, 0xd1, 0x81, 0x5b, 0xf0, 0xc3, 0xe1, 0x4c, 0x05, 0x85, 0xf3, 0x14, 0xde, 0x37, 0x8b, 0x43, 0xf9, 0xf4, 0xe4, 0x01, 0x31, 0x2c, 0x64, 0x5e, 0xfc, 0x70, 0xbd, 0x42, 0x96, 0x9b];
+pub const FIND_SESSIONS_BY_TOKEN_SET_QUERY_PLAN_HASH: [u8; 32] = [0x7e, 0x23, 0x18, 0x7b, 0x53, 0x75, 0x99, 0xc4, 0xc2, 0x36, 0x1d, 0x34, 0xea, 0x86, 0x6b, 0x5b, 0x71, 0x9f, 0x63, 0xfe, 0xda, 0x01, 0x35, 0x58, 0x7b, 0x5e, 0xc6, 0xaf, 0xd5, 0xce, 0x62, 0xf6];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct FindSessionsByTokenSetQuery(pub FindSessionsByTokenSetParams);
 impl GeneratedQuery for FindSessionsByTokenSetQuery {
@@ -2597,7 +2744,7 @@ impl FindSessionsByUserIdResult {
     }
 }
 
-pub const FIND_SESSIONS_BY_USER_ID_QUERY_PLAN_HASH: [u8; 32] = [0x84, 0xde, 0x4c, 0xd8, 0x40, 0xd3, 0x0d, 0xc9, 0xcd, 0x57, 0x5e, 0x1f, 0x1d, 0xae, 0xa8, 0xde, 0x94, 0xf0, 0xef, 0xa6, 0x31, 0x87, 0xb6, 0x46, 0xe2, 0x73, 0xba, 0x63, 0x3a, 0x5d, 0x69, 0x3f];
+pub const FIND_SESSIONS_BY_USER_ID_QUERY_PLAN_HASH: [u8; 32] = [0xa3, 0x27, 0x75, 0x46, 0xd8, 0xb0, 0xc0, 0x05, 0x9b, 0x85, 0x0c, 0x36, 0x8a, 0xe4, 0x92, 0x50, 0x00, 0xc2, 0x55, 0xe6, 0x9b, 0x7f, 0xf0, 0x05, 0xf4, 0xb3, 0xd2, 0xef, 0x61, 0xb5, 0x04, 0xaf];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct FindSessionsByUserIdQuery(pub FindSessionsByUserIdParams);
 impl GeneratedQuery for FindSessionsByUserIdQuery {
@@ -2710,7 +2857,7 @@ impl FindUserByEmailResult {
     }
 }
 
-pub const FIND_USER_BY_EMAIL_QUERY_PLAN_HASH: [u8; 32] = [0xef, 0x64, 0x7a, 0x48, 0xd5, 0x5b, 0x82, 0x5d, 0xbe, 0x56, 0x6c, 0x29, 0xb0, 0x3d, 0xd3, 0xfb, 0x97, 0x44, 0x4d, 0xf4, 0x9f, 0x99, 0x1b, 0xd0, 0x44, 0x1d, 0x60, 0xcb, 0xb4, 0x11, 0x50, 0x78];
+pub const FIND_USER_BY_EMAIL_QUERY_PLAN_HASH: [u8; 32] = [0xb1, 0x67, 0xb8, 0xcb, 0x2f, 0xb5, 0xce, 0x19, 0x68, 0x54, 0x91, 0xb4, 0x7d, 0xa4, 0xe8, 0x16, 0x66, 0x5b, 0x84, 0x0e, 0x0f, 0x0e, 0x46, 0x36, 0x66, 0xf6, 0x30, 0x21, 0x34, 0x47, 0x2b, 0x9a];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct FindUserByEmailQuery(pub FindUserByEmailParams);
 impl GeneratedQuery for FindUserByEmailQuery {
@@ -2869,7 +3016,7 @@ impl FindUserByIdResult {
     }
 }
 
-pub const FIND_USER_BY_ID_QUERY_PLAN_HASH: [u8; 32] = [0x45, 0xfe, 0x0e, 0x1b, 0xda, 0x91, 0xec, 0xd5, 0x2e, 0x3a, 0x5c, 0x64, 0xc6, 0x56, 0xc1, 0x68, 0xc1, 0x20, 0x0b, 0x18, 0x69, 0xb0, 0xf6, 0x86, 0x65, 0xfd, 0x9e, 0x57, 0x84, 0x39, 0xb9, 0xfd];
+pub const FIND_USER_BY_ID_QUERY_PLAN_HASH: [u8; 32] = [0x25, 0xd4, 0xa0, 0xa7, 0x7d, 0x5d, 0xf6, 0x4a, 0xb6, 0x18, 0x75, 0x28, 0xf9, 0xfa, 0xc6, 0xb2, 0x05, 0xa0, 0x3c, 0x33, 0xe0, 0x1c, 0x9e, 0xa6, 0xb5, 0x73, 0xe8, 0x31, 0x6b, 0x78, 0xb9, 0x24];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct FindUserByIdQuery(pub FindUserByIdParams);
 impl GeneratedQuery for FindUserByIdQuery {
@@ -3030,7 +3177,7 @@ impl FindVerificationByIdResult {
     }
 }
 
-pub const FIND_VERIFICATION_BY_ID_QUERY_PLAN_HASH: [u8; 32] = [0x37, 0x55, 0xec, 0xeb, 0x56, 0x78, 0x01, 0xc6, 0x79, 0x5c, 0x13, 0xa9, 0xe8, 0x86, 0x89, 0x55, 0xcf, 0xe1, 0xbf, 0x18, 0x5d, 0x20, 0x41, 0x96, 0xf4, 0xc6, 0x14, 0xd2, 0x9f, 0x78, 0xc6, 0xaa];
+pub const FIND_VERIFICATION_BY_ID_QUERY_PLAN_HASH: [u8; 32] = [0x54, 0xf0, 0x7c, 0x7e, 0xba, 0x7d, 0x51, 0x85, 0x7d, 0xd6, 0x47, 0x3e, 0x39, 0x30, 0x4d, 0xc7, 0x98, 0xbf, 0x70, 0x84, 0xca, 0x94, 0x6d, 0xfa, 0x7f, 0x02, 0x03, 0x63, 0x3a, 0x51, 0x33, 0xac];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct FindVerificationByIdQuery(pub FindVerificationByIdParams);
 impl GeneratedQuery for FindVerificationByIdQuery {
@@ -3161,7 +3308,7 @@ impl FindVerificationsByIdentifierResult {
     }
 }
 
-pub const FIND_VERIFICATIONS_BY_IDENTIFIER_QUERY_PLAN_HASH: [u8; 32] = [0xd9, 0x8f, 0x43, 0xe1, 0x46, 0x03, 0x2b, 0x3c, 0xd1, 0xd0, 0xdf, 0xb2, 0xea, 0xcd, 0x43, 0x27, 0x95, 0xf1, 0x54, 0x5f, 0xcf, 0xa0, 0x0e, 0x0e, 0x45, 0xb0, 0xfb, 0xd8, 0x91, 0xd8, 0xb3, 0xed];
+pub const FIND_VERIFICATIONS_BY_IDENTIFIER_QUERY_PLAN_HASH: [u8; 32] = [0x4c, 0x76, 0x8a, 0xe1, 0xd9, 0x66, 0x45, 0x4e, 0x9b, 0x79, 0x1c, 0xd5, 0x7a, 0x63, 0x11, 0x47, 0x69, 0x47, 0xb5, 0xc4, 0x57, 0x02, 0x09, 0x43, 0xa5, 0x0b, 0xc3, 0xcf, 0xee, 0x90, 0x76, 0x5b];
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct FindVerificationsByIdentifierQuery(pub FindVerificationsByIdentifierParams);
 impl GeneratedQuery for FindVerificationsByIdentifierQuery {
@@ -3603,6 +3750,76 @@ impl GeneratedCommand for ConsumeVerificationSetInput {
     }
 }
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ConsumeVerificationSnapshotInput {
+    pub request_id: String,
+    pub organization_id: String,
+    pub verification_id: String,
+    pub expected_revision: u64,
+}
+
+#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum ConsumeVerificationSnapshotOutcome {
+    VerificationConsumed,
+
+    VerificationConsumeStale,
+
+    VerificationConsumeMissing,
+}
+
+#[allow(dead_code)]
+impl ConsumeVerificationSnapshotOutcome {
+    #[must_use]
+    pub const fn is_verification_consumed(&self) -> bool {
+        matches!(self, Self::VerificationConsumed)
+    }
+    #[must_use]
+    pub const fn is_verification_consume_stale(&self) -> bool {
+        matches!(self, Self::VerificationConsumeStale)
+    }
+    #[must_use]
+    pub const fn is_verification_consume_missing(&self) -> bool {
+        matches!(self, Self::VerificationConsumeMissing)
+    }
+}
+
+const CONSUME_VERIFICATION_SNAPSHOT_PLAN_HASH: [u8; 32] = [0x1a, 0x80, 0xa3, 0x6f, 0x34, 0xb4, 0x69, 0x9c, 0x97, 0x2f, 0xc1, 0xe6, 0xf4, 0x8c, 0xad, 0x3f, 0x85, 0xda, 0x54, 0xe2, 0x02, 0x83, 0x1a, 0x69, 0x86, 0xae, 0xa0, 0x84, 0xdb, 0x09, 0x78, 0x8b];
+impl GeneratedCommand for ConsumeVerificationSnapshotInput {
+    type Outcome = ConsumeVerificationSnapshotOutcome;
+
+    fn idempotent_command(&self) -> Result<IdempotentCommand, GeneratedCommandError> {
+
+        let fields = vec![
+            wire_named_field("request_id", wire_uuid(&self.request_id)?),
+            wire_named_field("organization_id", wire_uuid(&self.organization_id)?),
+            wire_named_field("verification_id", wire_uuid(&self.verification_id)?),
+            wire_named_field("expected_revision", wire_u64(self.expected_revision)),
+        ];
+        IdempotentCommand::new("ConsumeVerificationSnapshot", Some(CONTRACT_VERSION), wire_record(fields)).map_err(Into::into)
+    }
+
+    fn outcome_request(&self, request_id: riffdb_client_rust::RequestId) -> Result<v1::GetOutcomeRequest, GeneratedCommandError> {
+        Ok(v1::GetOutcomeRequest {
+            request_id: request_id.into_bytes().to_vec(),
+            contract_lineage: CONTRACT_LINEAGE.to_owned(),
+            command_name: "ConsumeVerificationSnapshot".to_owned(),
+            idempotency_key: self.request_id.clone(),
+            outcome_uri: None,
+        })
+    }
+
+    fn decode_outcome(&self, response: &v1::ExecuteCommandResponse) -> Result<Self::Outcome, GeneratedCommandError> {
+        let fields = wire_outcome_fields(response, &CONSUME_VERIFICATION_SNAPSHOT_PLAN_HASH)?;
+        match response.outcome_type.as_str() {
+            "VerificationConsumed" => if fields.is_empty() { Ok(Self::Outcome::VerificationConsumed) } else { Err(GeneratedCommandError::InvalidOutcomeShape) },
+            "VerificationConsumeStale" => if fields.is_empty() { Ok(Self::Outcome::VerificationConsumeStale) } else { Err(GeneratedCommandError::InvalidOutcomeShape) },
+            "VerificationConsumeMissing" => if fields.is_empty() { Ok(Self::Outcome::VerificationConsumeMissing) } else { Err(GeneratedCommandError::InvalidOutcomeShape) },
+            _ => Err(GeneratedCommandError::InvalidOutcomeShape),
+        }
+    }
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct CreateAccountInput {
     pub id: String,
@@ -4397,6 +4614,110 @@ impl GeneratedCommand for DeleteVerificationInput {
     }
 }
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ResetCredentialPasswordInput {
+    pub user_id: String,
+    pub password: String,
+    pub account_id: String,
+    pub request_id: String,
+    pub updated_at: TimestampValue,
+    pub organization_id: String,
+    pub account_revision: u64,
+    pub verification_ids: Vec<String>,
+    pub external_account_id: String,
+    pub verification_revision: u64,
+}
+
+#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum ResetCredentialPasswordOutcome {
+    PasswordAccountStale,
+
+    PasswordAccountMissing,
+
+    CredentialPasswordReset,
+
+    PasswordProviderMismatch,
+
+    VerificationConsumeStale,
+
+    VerificationConsumeMissing,
+}
+
+#[allow(dead_code)]
+impl ResetCredentialPasswordOutcome {
+    #[must_use]
+    pub const fn is_password_account_stale(&self) -> bool {
+        matches!(self, Self::PasswordAccountStale)
+    }
+    #[must_use]
+    pub const fn is_password_account_missing(&self) -> bool {
+        matches!(self, Self::PasswordAccountMissing)
+    }
+    #[must_use]
+    pub const fn is_credential_password_reset(&self) -> bool {
+        matches!(self, Self::CredentialPasswordReset)
+    }
+    #[must_use]
+    pub const fn is_password_provider_mismatch(&self) -> bool {
+        matches!(self, Self::PasswordProviderMismatch)
+    }
+    #[must_use]
+    pub const fn is_verification_consume_stale(&self) -> bool {
+        matches!(self, Self::VerificationConsumeStale)
+    }
+    #[must_use]
+    pub const fn is_verification_consume_missing(&self) -> bool {
+        matches!(self, Self::VerificationConsumeMissing)
+    }
+}
+
+const RESET_CREDENTIAL_PASSWORD_PLAN_HASH: [u8; 32] = [0xed, 0x87, 0xf2, 0x67, 0x83, 0x1f, 0xb0, 0x82, 0x3b, 0x0e, 0x9b, 0xbf, 0x51, 0xd7, 0xb3, 0x02, 0xa7, 0x15, 0xa9, 0x5c, 0x0c, 0xea, 0x69, 0xfa, 0xf7, 0x92, 0x2c, 0x0e, 0x4e, 0x7f, 0x37, 0x5e];
+impl GeneratedCommand for ResetCredentialPasswordInput {
+    type Outcome = ResetCredentialPasswordOutcome;
+
+    fn idempotent_command(&self) -> Result<IdempotentCommand, GeneratedCommandError> {
+
+        if self.verification_ids.is_empty() || self.verification_ids.len() > 1 { return Err(GeneratedCommandError::InvalidInputShape); }
+        let fields = vec![
+            wire_named_field("user_id", wire_uuid(&self.user_id)?),
+            wire_named_field("password", wire_string(Clone::clone(&self.password))),
+            wire_named_field("account_id", wire_uuid(&self.account_id)?),
+            wire_named_field("request_id", wire_uuid(&self.request_id)?),
+            wire_named_field("updated_at", wire_timestamp(&self.updated_at)?),
+            wire_named_field("organization_id", wire_uuid(&self.organization_id)?),
+            wire_named_field("account_revision", wire_u64(self.account_revision)),
+            wire_named_field("verification_ids", v1::Value { kind: Some(WireKind::ListValue(v1::ValueList { values: (self.verification_ids).iter().map(|value| wire_uuid(value)).collect::<Result<Vec<_>, GeneratedCommandError>>()? })) }),
+            wire_named_field("external_account_id", wire_string(Clone::clone(&self.external_account_id))),
+            wire_named_field("verification_revision", wire_u64(self.verification_revision)),
+        ];
+        IdempotentCommand::new("ResetCredentialPassword", Some(CONTRACT_VERSION), wire_record(fields)).map_err(Into::into)
+    }
+
+    fn outcome_request(&self, request_id: riffdb_client_rust::RequestId) -> Result<v1::GetOutcomeRequest, GeneratedCommandError> {
+        Ok(v1::GetOutcomeRequest {
+            request_id: request_id.into_bytes().to_vec(),
+            contract_lineage: CONTRACT_LINEAGE.to_owned(),
+            command_name: "ResetCredentialPassword".to_owned(),
+            idempotency_key: self.request_id.clone(),
+            outcome_uri: None,
+        })
+    }
+
+    fn decode_outcome(&self, response: &v1::ExecuteCommandResponse) -> Result<Self::Outcome, GeneratedCommandError> {
+        let fields = wire_outcome_fields(response, &RESET_CREDENTIAL_PASSWORD_PLAN_HASH)?;
+        match response.outcome_type.as_str() {
+            "PasswordAccountStale" => if fields.is_empty() { Ok(Self::Outcome::PasswordAccountStale) } else { Err(GeneratedCommandError::InvalidOutcomeShape) },
+            "PasswordAccountMissing" => if fields.is_empty() { Ok(Self::Outcome::PasswordAccountMissing) } else { Err(GeneratedCommandError::InvalidOutcomeShape) },
+            "CredentialPasswordReset" => if fields.is_empty() { Ok(Self::Outcome::CredentialPasswordReset) } else { Err(GeneratedCommandError::InvalidOutcomeShape) },
+            "PasswordProviderMismatch" => if fields.is_empty() { Ok(Self::Outcome::PasswordProviderMismatch) } else { Err(GeneratedCommandError::InvalidOutcomeShape) },
+            "VerificationConsumeStale" => if fields.is_empty() { Ok(Self::Outcome::VerificationConsumeStale) } else { Err(GeneratedCommandError::InvalidOutcomeShape) },
+            "VerificationConsumeMissing" => if fields.is_empty() { Ok(Self::Outcome::VerificationConsumeMissing) } else { Err(GeneratedCommandError::InvalidOutcomeShape) },
+            _ => Err(GeneratedCommandError::InvalidOutcomeShape),
+        }
+    }
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct UpdateAccountInput {
     pub scope: Option<String>,
@@ -4567,6 +4888,91 @@ impl GeneratedCommand for UpdateAccountPasswordsInput {
     }
 }
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct UpdateCredentialPasswordInput {
+    pub user_id: String,
+    pub password: String,
+    pub account_id: String,
+    pub request_id: String,
+    pub updated_at: TimestampValue,
+    pub organization_id: String,
+    pub expected_revision: u64,
+    pub external_account_id: String,
+}
+
+#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum UpdateCredentialPasswordOutcome {
+    PasswordAccountStale,
+
+    PasswordAccountMissing,
+
+    PasswordProviderMismatch,
+
+    CredentialPasswordUpdated,
+}
+
+#[allow(dead_code)]
+impl UpdateCredentialPasswordOutcome {
+    #[must_use]
+    pub const fn is_password_account_stale(&self) -> bool {
+        matches!(self, Self::PasswordAccountStale)
+    }
+    #[must_use]
+    pub const fn is_password_account_missing(&self) -> bool {
+        matches!(self, Self::PasswordAccountMissing)
+    }
+    #[must_use]
+    pub const fn is_password_provider_mismatch(&self) -> bool {
+        matches!(self, Self::PasswordProviderMismatch)
+    }
+    #[must_use]
+    pub const fn is_credential_password_updated(&self) -> bool {
+        matches!(self, Self::CredentialPasswordUpdated)
+    }
+}
+
+const UPDATE_CREDENTIAL_PASSWORD_PLAN_HASH: [u8; 32] = [0x08, 0x78, 0x1a, 0x68, 0x73, 0x9c, 0x70, 0x5a, 0xb6, 0xff, 0xe5, 0x1a, 0x0d, 0xe5, 0x47, 0x60, 0x5e, 0x1a, 0x7d, 0xd2, 0xfd, 0x2b, 0x80, 0x75, 0x44, 0x5d, 0x40, 0xdb, 0x92, 0x3d, 0x1f, 0x15];
+impl GeneratedCommand for UpdateCredentialPasswordInput {
+    type Outcome = UpdateCredentialPasswordOutcome;
+
+    fn idempotent_command(&self) -> Result<IdempotentCommand, GeneratedCommandError> {
+
+        let fields = vec![
+            wire_named_field("user_id", wire_uuid(&self.user_id)?),
+            wire_named_field("password", wire_string(Clone::clone(&self.password))),
+            wire_named_field("account_id", wire_uuid(&self.account_id)?),
+            wire_named_field("request_id", wire_uuid(&self.request_id)?),
+            wire_named_field("updated_at", wire_timestamp(&self.updated_at)?),
+            wire_named_field("organization_id", wire_uuid(&self.organization_id)?),
+            wire_named_field("expected_revision", wire_u64(self.expected_revision)),
+            wire_named_field("external_account_id", wire_string(Clone::clone(&self.external_account_id))),
+        ];
+        IdempotentCommand::new("UpdateCredentialPassword", Some(CONTRACT_VERSION), wire_record(fields)).map_err(Into::into)
+    }
+
+    fn outcome_request(&self, request_id: riffdb_client_rust::RequestId) -> Result<v1::GetOutcomeRequest, GeneratedCommandError> {
+        Ok(v1::GetOutcomeRequest {
+            request_id: request_id.into_bytes().to_vec(),
+            contract_lineage: CONTRACT_LINEAGE.to_owned(),
+            command_name: "UpdateCredentialPassword".to_owned(),
+            idempotency_key: self.request_id.clone(),
+            outcome_uri: None,
+        })
+    }
+
+    fn decode_outcome(&self, response: &v1::ExecuteCommandResponse) -> Result<Self::Outcome, GeneratedCommandError> {
+        let fields = wire_outcome_fields(response, &UPDATE_CREDENTIAL_PASSWORD_PLAN_HASH)?;
+        match response.outcome_type.as_str() {
+            "PasswordAccountStale" => if fields.is_empty() { Ok(Self::Outcome::PasswordAccountStale) } else { Err(GeneratedCommandError::InvalidOutcomeShape) },
+            "PasswordAccountMissing" => if fields.is_empty() { Ok(Self::Outcome::PasswordAccountMissing) } else { Err(GeneratedCommandError::InvalidOutcomeShape) },
+            "PasswordProviderMismatch" => if fields.is_empty() { Ok(Self::Outcome::PasswordProviderMismatch) } else { Err(GeneratedCommandError::InvalidOutcomeShape) },
+            "CredentialPasswordUpdated" => if fields.is_empty() { Ok(Self::Outcome::CredentialPasswordUpdated) } else { Err(GeneratedCommandError::InvalidOutcomeShape) },
+            _ => Err(GeneratedCommandError::InvalidOutcomeShape),
+        }
+    }
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct UpdateSessionInput {
     pub user_id: String,
@@ -5249,6 +5655,27 @@ impl RiffDBBetterAuthCoreClient {
         Ok(pages)
     }
 
+    /// Executes the generated `FindCredentialAccount` named query.
+    pub async fn find_credential_account(&mut self, parameters: FindCredentialAccountParams) -> Result<FindCredentialAccountResult, ApplicationClientError> {
+        let options = match self.read_after_commit {
+            Some(commit_sequence) => QueryOptions::new().read_after_commit(commit_sequence),
+            None => QueryOptions::new(),
+        };
+        Ok(self.find_credential_account_with_options(parameters, options).await?.value)
+    }
+    /// Executes `FindCredentialAccount` against a snapshot at or after the supplied command commit.
+    pub async fn find_credential_account_after_commit(&mut self, parameters: FindCredentialAccountParams, commit_sequence: u64) -> Result<TypedQueryResult<FindCredentialAccountResult>, ApplicationClientError> {
+        self.find_credential_account_with_options(parameters, QueryOptions::new().read_after_commit(commit_sequence)).await
+    }
+    /// Executes `FindCredentialAccount` with generated pagination or read-fence options.
+    pub async fn find_credential_account_with_options(&mut self, parameters: FindCredentialAccountParams, options: QueryOptions) -> Result<TypedQueryResult<FindCredentialAccountResult>, ApplicationClientError> {
+        let options = match self.read_after_commit {
+            Some(commit_sequence) if options == QueryOptions::new() => options.read_after_commit(commit_sequence),
+            _ => options,
+        };
+        self.client.execute_generated_query(FindCredentialAccountQuery(parameters), options, &self.metadata).await
+    }
+
     /// Executes the generated `FindExpiredVerificationIds` named query.
     pub async fn find_expired_verification_ids(&mut self, parameters: FindExpiredVerificationIdsParams) -> Result<FindExpiredVerificationIdsResult, ApplicationClientError> {
         let options = match self.read_after_commit {
@@ -5574,6 +6001,29 @@ impl RiffDBBetterAuthCoreClient {
         self.client.execute_generated_command_batch_with_progress(inputs, options, self.command_attempts, &self.metadata, progress).await
     }
 
+    pub async fn consume_verification_snapshot(&mut self, input: ConsumeVerificationSnapshotInput) -> Result<TypedCommandResult<ConsumeVerificationSnapshotOutcome>, ApplicationClientError> {
+        let result: TypedCommandResult<ConsumeVerificationSnapshotOutcome> = self.client.execute_generated_command(&input, self.command_attempts, &self.metadata).await?;
+        if self.track_causal_writes
+            && let Some(commit_sequence) = result.commit_sequence
+            && commit_sequence > 0
+            && self.read_after_commit.is_none_or(|current| commit_sequence > current)
+        {
+            self.read_after_commit = Some(commit_sequence);
+        }
+        Ok(result)
+    }
+
+    pub async fn consume_verification_snapshot_batch(&self, inputs: Vec<ConsumeVerificationSnapshotInput>, options: GeneratedBatchOptions) -> Result<GeneratedBatchResult<ConsumeVerificationSnapshotOutcome>, GeneratedBatchError> {
+        self.client.execute_generated_command_batch(inputs, options, self.command_attempts, &self.metadata).await
+    }
+
+    pub async fn consume_verification_snapshot_batch_with_progress<F>(&self, inputs: Vec<ConsumeVerificationSnapshotInput>, options: GeneratedBatchOptions, progress: F) -> Result<GeneratedBatchResult<ConsumeVerificationSnapshotOutcome>, GeneratedBatchError>
+    where
+        F: FnMut(GeneratedBatchProgress),
+    {
+        self.client.execute_generated_command_batch_with_progress(inputs, options, self.command_attempts, &self.metadata, progress).await
+    }
+
     pub async fn create_account(&mut self, input: CreateAccountInput) -> Result<TypedCommandResult<CreateAccountOutcome>, ApplicationClientError> {
         let result: TypedCommandResult<CreateAccountOutcome> = self.client.execute_generated_command(&input, self.command_attempts, &self.metadata).await?;
         if self.track_causal_writes
@@ -5804,6 +6254,29 @@ impl RiffDBBetterAuthCoreClient {
         self.client.execute_generated_command_batch_with_progress(inputs, options, self.command_attempts, &self.metadata, progress).await
     }
 
+    pub async fn reset_credential_password(&mut self, input: ResetCredentialPasswordInput) -> Result<TypedCommandResult<ResetCredentialPasswordOutcome>, ApplicationClientError> {
+        let result: TypedCommandResult<ResetCredentialPasswordOutcome> = self.client.execute_generated_command(&input, self.command_attempts, &self.metadata).await?;
+        if self.track_causal_writes
+            && let Some(commit_sequence) = result.commit_sequence
+            && commit_sequence > 0
+            && self.read_after_commit.is_none_or(|current| commit_sequence > current)
+        {
+            self.read_after_commit = Some(commit_sequence);
+        }
+        Ok(result)
+    }
+
+    pub async fn reset_credential_password_batch(&self, inputs: Vec<ResetCredentialPasswordInput>, options: GeneratedBatchOptions) -> Result<GeneratedBatchResult<ResetCredentialPasswordOutcome>, GeneratedBatchError> {
+        self.client.execute_generated_command_batch(inputs, options, self.command_attempts, &self.metadata).await
+    }
+
+    pub async fn reset_credential_password_batch_with_progress<F>(&self, inputs: Vec<ResetCredentialPasswordInput>, options: GeneratedBatchOptions, progress: F) -> Result<GeneratedBatchResult<ResetCredentialPasswordOutcome>, GeneratedBatchError>
+    where
+        F: FnMut(GeneratedBatchProgress),
+    {
+        self.client.execute_generated_command_batch_with_progress(inputs, options, self.command_attempts, &self.metadata, progress).await
+    }
+
     pub async fn update_account(&mut self, input: UpdateAccountInput) -> Result<TypedCommandResult<UpdateAccountOutcome>, ApplicationClientError> {
         let result: TypedCommandResult<UpdateAccountOutcome> = self.client.execute_generated_command(&input, self.command_attempts, &self.metadata).await?;
         if self.track_causal_writes
@@ -5850,6 +6323,29 @@ impl RiffDBBetterAuthCoreClient {
         self.client.execute_generated_command_batch_with_progress(inputs, options, self.command_attempts, &self.metadata, progress).await
     }
 
+    pub async fn update_credential_password(&mut self, input: UpdateCredentialPasswordInput) -> Result<TypedCommandResult<UpdateCredentialPasswordOutcome>, ApplicationClientError> {
+        let result: TypedCommandResult<UpdateCredentialPasswordOutcome> = self.client.execute_generated_command(&input, self.command_attempts, &self.metadata).await?;
+        if self.track_causal_writes
+            && let Some(commit_sequence) = result.commit_sequence
+            && commit_sequence > 0
+            && self.read_after_commit.is_none_or(|current| commit_sequence > current)
+        {
+            self.read_after_commit = Some(commit_sequence);
+        }
+        Ok(result)
+    }
+
+    pub async fn update_credential_password_batch(&self, inputs: Vec<UpdateCredentialPasswordInput>, options: GeneratedBatchOptions) -> Result<GeneratedBatchResult<UpdateCredentialPasswordOutcome>, GeneratedBatchError> {
+        self.client.execute_generated_command_batch(inputs, options, self.command_attempts, &self.metadata).await
+    }
+
+    pub async fn update_credential_password_batch_with_progress<F>(&self, inputs: Vec<UpdateCredentialPasswordInput>, options: GeneratedBatchOptions, progress: F) -> Result<GeneratedBatchResult<UpdateCredentialPasswordOutcome>, GeneratedBatchError>
+    where
+        F: FnMut(GeneratedBatchProgress),
+    {
+        self.client.execute_generated_command_batch_with_progress(inputs, options, self.command_attempts, &self.metadata, progress).await
+    }
+
     pub async fn update_session(&mut self, input: UpdateSessionInput) -> Result<TypedCommandResult<UpdateSessionOutcome>, ApplicationClientError> {
         let result: TypedCommandResult<UpdateSessionOutcome> = self.client.execute_generated_command(&input, self.command_attempts, &self.metadata).await?;
         if self.track_causal_writes